diff --git a/BUILD.gn b/BUILD.gn index cabef689c47c5dc20d5064a4f6e1a71754c94f63..e61b17d1458558f5729aacde70a103ebaee6da11 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -11,35 +11,41 @@ # See the License for the specific language governing permissions and # limitations under the License. -group("crypto_framework_lib") { +group("crypto_framework_component") { if (os_level == "standard") { deps = [ - "//base/security/crypto_framework/frameworks:crypto_framework_lib", + "frameworks:crypto_framework_lib", + "frameworks/js/napi/certificate:cert_napi", + "frameworks/js/napi/crypto:cryptoframework_napi", + "plugin:certificate_openssl_plugin_lib", + "plugin:crypto_openssl_plugin_lib", ] } } -group("crypto_openssl_plugin_lib") { - if (os_level == "standard") { - deps = [ - "//base/security/crypto_framework/plugin:crypto_openssl_plugin_lib", - ] - } -} - -group("cryptoframework_napi") { +group("crypto_framework_test") { + testonly = true if (os_level == "standard") { - deps = [ - "//base/security/crypto_framework/frameworks:cryptoframework_napi", - ] + deps = [ "test/unittest:crypto_framework_test" ] } } -group("crypto_framework_test") { +group("crypto_framework_fuzztest") { testonly = true + deps = [] if (os_level == "standard") { - deps = [ - "//base/security/crypto_framework/test/unittest:crypto_framework_test", + deps += [ + "test/fuzztest/certificate/x509certificate_fuzzer:fuzztest", + "test/fuzztest/certificate/x509crl_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfciphercreate_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfmaccreate_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfmdcreate_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfsigncreate_fuzzer:fuzztest", + "test/fuzztest/crypto_operation/hcfverifycreate_fuzzer:fuzztest", + "test/fuzztest/key/asykeygenerator_fuzzer:fuzztest", + "test/fuzztest/key/symkeygenerator_fuzzer:fuzztest", + "test/fuzztest/rand/hcfrandcreate_fuzzer:fuzztest", ] } } diff --git a/README_zh.md b/README_zh.md index 0918896d8f272910f1cc47a169e34fbd1b590e4d..28678cb6ff0fbb5c94768c54c7d20e328cb2d0cd 100644 --- a/README_zh.md +++ b/README_zh.md @@ -1,7 +1,17 @@ # 加解密算法库框架 ## 简介 -为屏蔽底层硬件和算法库，向上提供统一的密码算法库加解密和证书相关接口。 +加解密算法库框架是一个屏蔽了第三方密码学算法库实现差异的算法框架，提供加解密、签名验签、消息验证码、哈希、安全随机数和证书等相关功能。开发者可以通过调用加解密算法库框架，忽略底层不同三方算法库的差异，实现迅捷开发。 +**图 1** 加解密算法库框架-架构图 + + +![](figures/zh-cn_crypto_framework_architecture.png) + +其中， + +- API接口层：对外提供统一的JS接口，提供的能力包括：密码操作、证书、秘钥材料和生成器等。 +- 框架实现层：通过灵活加载插件层的插件，适配并屏蔽三方算法库的差异。 +- 插件实现层：实现针对具体三方算法库的功能。 ## 目录 ``` @@ -10,21 +20,37 @@ base/security/crypto_framwork ├── interfaces # 对外接口目录 ├── test # unitest ├── common # 内部依赖的公共方法 -├── plugin # 算法适配的插件 +├── plugin # 算法适配的插件实现 │ └── openssl_plugin # openssl 插件 -├── frameworks # api调用SPI的实现 -│ ├── spi # 放SPI的头文件 +├── frameworks # 框架实现层 +│ ├── spi # SPI的接口 │ ├── js │ └── napi # 通过napi封装的JS接口代码实现 │ ├── algorithm_parameter # 算法参数 │ ├── certificate # 证书 │ ├── crypto_operation # 算法操作，包括mac、md、加解密、签名验签、秘钥协商 -│ ├── key -│ └── rand +│ ├── key # 秘钥材料 +│ └── rand # 随机数 ``` +## 约束 +- [加解密算法库框架-overview-约束与限制](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/security/cryptoFramework-overview.md) +- [证书-overview-约束与限制](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/security/cert-overview.md) + +## 说明 + +### 接口说明 +- [加解密算法库框架-API参考](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-cryptoFramework.md) + +- [证书-API参考](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-cert.md) + +### 使用说明 +- [加解密算法库框架-开发指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/security/cryptoFramework-guidelines.md) + +- [证书-开发指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/security/cert-guidelines.md) + ## 相关仓 **安全子系统** -[security\_crypto\_framwork](https://gitee.com/openharmony/security_crypto_framwork) \ No newline at end of file +[security\_crypto\_framework](https://gitee.com/openharmony/security_crypto_framework) \ No newline at end of file diff --git a/bundle.json b/bundle.json index 59802e65fc96a1a927e173735ac87664a33d6b43..6ed02db51e1472317feeb5c133ed96a36838f6aa 100644 --- a/bundle.json +++ b/bundle.json @@ -14,7 +14,7 @@ "component": { "name": "crypto_framework", "subsystem": "security", - "syscap": [ "SystemCapability.Security.CryptoFramework" ], + "syscap": [ "SystemCapability.Security.CryptoFramework", "SystemCapability.Security.Cert" ], "features": [], "adapted_system_type": [ "standard" @@ -32,13 +32,47 @@ }, "build": { "sub_component": [ - "//base/security/crypto_framework:crypto_framework_lib", - "//base/security/crypto_framework:crypto_openssl_plugin_lib", - "//base/security/crypto_framework:cryptoframework_napi" + "//base/security/crypto_framework:crypto_framework_component" + ], + "inner_kits": [ + { + "name": "//base/security/crypto_framework/frameworks:crypto_framework_lib", + "header": { + "header_files": [ + "algorithm_parameter/algorithm_parameter.h", + "algorithm_parameter/detailed_ccm_params.h", + "algorithm_parameter/detailed_gcm_params.h", + "algorithm_parameter/detailed_iv_params.h", + "certificate/cert_chain_validator.h", + "certificate/certificate.h", + "certificate/crl.h", + "certificate/x509_certificate.h", + "certificate/x509_crl_entry.h", + "certificate/x509_crl.h", + "common/blob.h", + "common/object_base.h", + "common/result.h", + "crypto_operation/cipher.h", + "crypto_operation/key_agreement.h", + "crypto_operation/mac.h", + "crypto_operation/md.h", + "crypto_operation/signature.h", + "key/asy_key_generator.h", + "key/key_pair.h", + "key/key.h", + "key/pri_key.h", + "key/pub_key.h", + "key/sym_key_generator.h", + "key/sym_key.h", + "rand/rand.h" + ], + "header_base": "//base/security/crypto_framework/interfaces/innerkits" + } + } ], - "inner_kits": [], "test": [ - "//base/security/crypto_framework:crypto_framework_test" + "//base/security/crypto_framework:crypto_framework_test", + "//base/security/crypto_framework:crypto_framework_fuzztest" ] } } diff --git a/cfi_blocklist.txt b/cfi_blocklist.txt new file mode 100644 index 0000000000000000000000000000000000000000..b7fb0f1c9ed8978f5443d7068bd9fea274000871 --- /dev/null +++ b/cfi_blocklist.txt @@ -0,0 +1,6 @@ +src:*/frameworks/certificate/* +src:*/frameworks/crypto_operation/* +src:*/frameworks/key/* +src:*/frameworks/rand/* +src:*/frameworks/js/napi/certificate/src/* +src:*/frameworks/js/napi/crypto/src/* \ No newline at end of file diff --git a/common/common.gni b/common/common.gni index ceb413924fb86cf30c900a9fbd4d9a59bc751c63..264ae1da53085bbeb45c0c69d4e545d6e6362026 100644 --- a/common/common.gni +++ b/common/common.gni @@ -24,6 +24,7 @@ framework_common_util_files = [ "//base/security/crypto_framework/common/src/hcf_parcel.c", "//base/security/crypto_framework/common/src/hcf_string.c", "//base/security/crypto_framework/common/src/params_parser.c", + "//base/security/crypto_framework/common/src/object_base.c", ] crypto_framwork_common_files = framework_common_util_files diff --git a/common/inc/config.h b/common/inc/config.h index 5ca803c2057ef352848e0dc3e38a8ecb901708b0..cefcd5f31c92cbba67825dae4be49003176179fe 100644 --- a/common/inc/config.h +++ b/common/inc/config.h @@ -20,8 +20,8 @@ #define HCF_MAX_ALGO_NAME_LEN 128 // input algoName parameter max length limit, include \0 #define LOG_PRINT_MAX_LEN 1024 // log max length limit #define HCF_MAX_BUFFER_LEN 8192 +#define SERIAL_NUMBER_HEDER_SIZE 2 #define INVALID_VERSION (-1) -#define INVALID_SERIAL_NUMBER (-1) #define INVALID_CONSTRAINTS_LEN (-1) #endif diff --git a/common/inc/hcf_string.h b/common/inc/hcf_string.h index 29eceb05af2c6b3235e51c3a74a22dc5454323af..56f3ca70d85df2825b6f6de7bc4be0ae0bc3effd 100644 --- a/common/inc/hcf_string.h +++ b/common/inc/hcf_string.h @@ -26,15 +26,6 @@ extern "C" { HcParcel parcel; // parcel data, used to storage the string data } HcString; - /* - * Append a HcString - * Notice: It will add '\0' automatically. - * @param self: self pointer. - * @param str: append string. - * @return true (ok), false (error) - */ - bool StringAppend(HcString *self, HcString str); - /* * Append string pointer * Notice: It will add '\0' automatically. @@ -44,15 +35,6 @@ extern "C" { */ bool StringAppendPointer(HcString *self, const char *str); - /* - * Assign a value to the HcString - * Notice: It will add '\0' automatically. - * @param self: self pointer. - * @param str: assign value of ta_sting. - * @return true (ok), false (error) - */ - bool StringSet(HcString *self, HcString str); - /* * Assign a value to the HcString * Notice: It will add '\0' automatically. diff --git a/common/inc/params_parser.h b/common/inc/params_parser.h index 5288d8f5c32502a98787ecb72533da5943563776..e29f3256da4813ad362464df4126248a92e6582b 100644 --- a/common/inc/params_parser.h +++ b/common/inc/params_parser.h @@ -1,5 +1,5 @@ /* -* Copyright (C) 2021 Huawei Device Co., Ltd. +* Copyright (C) 2022-2023 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 @@ -40,7 +40,7 @@ typedef enum { HCF_ALG_ECC_224 = 1, HCF_ALG_ECC_256, HCF_ALG_ECC_384, - HCF_ALG_ECC_512, + HCF_ALG_ECC_521, HCF_ALG_AES_128, HCF_ALG_AES_192, @@ -134,7 +134,7 @@ typedef HcfResult (*SetParameterFunc) (const HcfParaConfig* config, void *params extern "C" { #endif -HcfResult ParseAndSetParameter(const char* paramsStr, void *params, SetParameterFunc setFunc); +HcfResult ParseAndSetParameter(const char *paramsStr, void *params, SetParameterFunc setFunc); #ifdef __cplusplus } diff --git a/common/src/blob.c b/common/src/blob.c index 47056f390b161ee41299a3388deb451de2d29a05..6d66098dc487cb667ef8ffd6f342f1dc73bb6af8 100644 --- a/common/src/blob.c +++ b/common/src/blob.c @@ -63,6 +63,7 @@ void HcfArrayDataClearAndFree(HcfArray *array) array->data[i].data = NULL; array->data[i].len = 0; } + array->count = 0; HcfFree(array->data); array->data = NULL; } diff --git a/common/src/hcf_string.c b/common/src/hcf_string.c index 5d3eb61b586044b72026b878a9194cbfa35e6efe..8d1b3d628c50694c91a2a4119d5df39168faf115 100644 --- a/common/src/hcf_string.c +++ b/common/src/hcf_string.c @@ -22,26 +22,6 @@ const char STRING_END_CHAR = '\0'; #define MAX_INT 0x7FFFFFFF #define MAX_UINT 0xFFFFFFFF -/* -* Append a HcString -* Notice: It will add '\0' automatically. -* @param self: self pointer. -* @param str: append string. -* @return true (ok), false (error) -*/ -bool StringAppend(HcString *self, HcString str) -{ - uint32_t length = GetParcelDataSize(&str.parcel); - if (self != NULL && length > 0) { - // remove '\0' - ParcelPopBack(&self->parcel, STRING_END_CHAR_LENGTH); - // append string(include '\0') - return StringAppendPointer(self, GetParcelData(&str.parcel)); - } - - return false; -} - /* * Append string pointer * Notice: It will add '\0' automatically. @@ -61,23 +41,6 @@ bool StringAppendPointer(HcString *self, const char *str) return false; } -/* -* Assign a value to the HcString -* Notice: It will add '\0' automatically. -* @param self: self pointer. -* @param str: assign value of ta_sting. -* @return true (ok), false (error) -*/ -bool StringSet(HcString *self, HcString str) -{ - if (self != NULL) { - DeleteParcel(&self->parcel); - return StringAppend(self, str); - } - - return false; -} - /* * Assign a value to the HcString * Notice: It will add '\0' automatically. diff --git a/common/src/object_base.c b/common/src/object_base.c new file mode 100644 index 0000000000000000000000000000000000000000..d3ff9178b45dca9b5938a3410eb2debd934be213 --- /dev/null +++ b/common/src/object_base.c @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2022 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 "object_base.h" + +#include + +void HcfObjDestroy(void *obj) +{ + if (obj != NULL) { + ((HcfObjectBase *)obj)->destroy((HcfObjectBase *)obj); + } +} diff --git a/common/src/params_parser.c b/common/src/params_parser.c index d373ea9343a47efadea77e267a2a8c1a6974c25d..8aa0ccd14a722ed2e1d4aa2e01c64ce0348394e2 100644 --- a/common/src/params_parser.c +++ b/common/src/params_parser.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -20,11 +20,11 @@ #include "hcf_string.h" #include "log.h" -const HcfParaConfig gConfig[] = { +static const HcfParaConfig PARAM_CONFIG[] = { {"ECC224", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_224}, {"ECC256", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_256}, {"ECC384", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_384}, - {"ECC512", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_512}, + {"ECC521", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_521}, {"AES128", HCF_ALG_KEY_TYPE, HCF_ALG_AES_128}, {"AES192", HCF_ALG_KEY_TYPE, HCF_ALG_AES_192}, @@ -80,21 +80,21 @@ const HcfParaConfig gConfig[] = { }; -const HcfParaConfig* findConfig(const HcString* tag) +static const HcfParaConfig *FindConfig(const HcString* tag) { if (tag == NULL) { return NULL; } - for (uint32_t i = 0; i < sizeof(gConfig) / sizeof(HcfParaConfig); ++i) { - if (StringCompare(tag, gConfig[i].tag) == 0) { - return &gConfig[i]; + for (uint32_t i = 0; i < sizeof(PARAM_CONFIG) / sizeof(HcfParaConfig); ++i) { + if (StringCompare(tag, PARAM_CONFIG[i].tag) == 0) { + return &PARAM_CONFIG[i]; } } return NULL; } -HcfResult ParseAndSetParameter(const char* paramsStr, void *params, SetParameterFunc setFunc) +HcfResult ParseAndSetParameter(const char *paramsStr, void *params, SetParameterFunc setFunc) { if (paramsStr == NULL || setFunc == NULL) { return HCF_INVALID_PARAMS; @@ -115,7 +115,7 @@ HcfResult ParseAndSetParameter(const char* paramsStr, void *params, SetParameter LOGE("StringSubString failed!"); break; } - ret = (*setFunc)(findConfig(&subStr), params); + ret = (*setFunc)(FindConfig(&subStr), params); if (ret != HCF_SUCCESS) { break; } @@ -129,7 +129,7 @@ HcfResult ParseAndSetParameter(const char* paramsStr, void *params, SetParameter LOGE("get last string failed!"); break; } - ret = (*setFunc)(findConfig(&subStr), params); + ret = (*setFunc)(FindConfig(&subStr), params); break; } } while (true); diff --git a/common/src/utils.c b/common/src/utils.c index e4f10b291757e871687a450bd9d440e5bb062863..a66cbcec37214fd074620e18d284a3423ab9a0d3 100644 --- a/common/src/utils.c +++ b/common/src/utils.c @@ -45,7 +45,7 @@ bool IsClassMatch(const HcfObjectBase *obj, const char *className) if (strcmp(obj->getClass(), className) == 0) { return true; } else { - LOGE("class is not match. except class: %s, input class: %s", className, obj->getClass()); + LOGE("class is not match. expect class: %s, input class: %s", className, obj->getClass()); return false; } } diff --git a/figures/zh-cn_crypto_framework_architecture.png b/figures/zh-cn_crypto_framework_architecture.png new file mode 100755 index 0000000000000000000000000000000000000000..521a3850ff2216a624e0d732a0ddba60137d7bae Binary files /dev/null and b/figures/zh-cn_crypto_framework_architecture.png differ diff --git a/frameworks/BUILD.gn b/frameworks/BUILD.gn index 293f7d48aa68512ff43a7d9439c198a08638c55e..1892fce3c1c21249b11398d9f3373d70d2876845 100644 --- a/frameworks/BUILD.gn +++ b/frameworks/BUILD.gn @@ -30,69 +30,36 @@ ohos_shared_library("crypto_framework_lib") { subsystem_name = "security" part_name = "crypto_framework" public_configs = [ ":framework_config" ] - include_dirs = [ "//commonlibrary/c_utils/base/include" ] + include_dirs = [ + "//commonlibrary/c_utils/base/include", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + ] include_dirs += framework_inc_path + crypto_framwork_common_inc_path sources = framework_files + if (os_level == "standard") { + sanitize = { + cfi = true + debug = false + blocklist = "//base/security/crypto_framework/cfi_blocklist.txt" + } + } + cflags = [ + "-DHILOG_ENABLE", "-fPIC", "-Wall", ] deps = [ - "//base/security/crypto_framework:crypto_openssl_plugin_lib", - "//base/security/crypto_framework/common:crypto_plugin_common", - "//third_party/openssl:libcrypto_shared", - ] - - external_deps = [ "c_utils:utils" ] -} - -ohos_shared_library("cryptoframework_napi") { - subsystem_name = "security" - part_name = "crypto_framework" - relative_install_dir = "module/security" - include_dirs = [ - "//base/security/crypto_framework/interfaces/kits/js", - "//third_party/bounds_checking_function/include", - "//commonlibrary/c_utils/base/include", - "//base/security/crypto_framework/frameworks/js/napi/inc", - ] - include_dirs += framework_inc_path - - cflags = [ - "-fPIC", - "-g3", + "../common:crypto_plugin_common", + "../plugin:certificate_openssl_plugin_lib", + "../plugin:crypto_openssl_plugin_lib", ] - sources = [ - "js/napi/src/napi_asy_key_generator.cpp", - "js/napi/src/napi_cert_chain_validator.cpp", - "js/napi/src/napi_cipher.cpp", - "js/napi/src/napi_init.cpp", - "js/napi/src/napi_key.cpp", - "js/napi/src/napi_key_agreement.cpp", - "js/napi/src/napi_key_pair.cpp", - "js/napi/src/napi_mac.cpp", - "js/napi/src/napi_md.cpp", - "js/napi/src/napi_pri_key.cpp", - "js/napi/src/napi_pub_key.cpp", - "js/napi/src/napi_rand.cpp", - "js/napi/src/napi_sign.cpp", - "js/napi/src/napi_sym_key.cpp", - "js/napi/src/napi_sym_key_generator.cpp", - "js/napi/src/napi_utils.cpp", - "js/napi/src/napi_verify.cpp", - "js/napi/src/napi_x509_certificate.cpp", - "js/napi/src/napi_x509_crl.cpp", - "js/napi/src/napi_x509_crl_entry.cpp", + external_deps = [ + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", ] - - deps = [ - "//base/security/crypto_framework/frameworks:crypto_framework_lib", - "//third_party/bounds_checking_function:libsec_static", - ] - - external_deps = [ "napi:ace_napi" ] } diff --git a/frameworks/certificate/cert_chain_validator.c b/frameworks/certificate/cert_chain_validator.c index cd28c06875aa56ffb5f076b83cabffe05bd5967f..09fa4d2b6d6fb3f3dc86008628b08042d0143a87 100644 --- a/frameworks/certificate/cert_chain_validator.c +++ b/frameworks/certificate/cert_chain_validator.c @@ -53,7 +53,7 @@ static const HcfCertChainValidatorAbility CERT_PATH_VALIDATOR_ABILITY_SET[] = { static const HcfCertChainValidatorFuncSet *FindAbility(const char *algorithm) { - for (uint32_t i = 0; i < sizeof(CERT_PATH_VALIDATOR_ABILITY_SET); i++) { + for (uint32_t i = 0; i < sizeof(CERT_PATH_VALIDATOR_ABILITY_SET) / sizeof(HcfCertChainValidatorAbility); i++) { if (strcmp(CERT_PATH_VALIDATOR_ABILITY_SET[i].algorithm, algorithm) == 0) { return &(CERT_PATH_VALIDATOR_ABILITY_SET[i].funcSet); } @@ -71,13 +71,14 @@ static void DestroyCertChainValidator(HcfObjectBase *self) { if (self == NULL) { LOGE("Invalid input parameter."); + return; } if (!IsClassMatch(self, GetCertChainValidatorClass())) { LOGE("Class is not match."); return; } CertChainValidatorImpl *validatorImpl = (CertChainValidatorImpl *)self; - OH_HCF_OBJ_DESTROY(validatorImpl->spiObj); + HcfObjDestroy(validatorImpl->spiObj); HcfFree(validatorImpl->algorithm); validatorImpl->algorithm = NULL; HcfFree(validatorImpl); @@ -203,14 +204,7 @@ HcfResult HcfCertChainValidatorCreate(const char *algorithm, HcfCertChainValidat HcfFree(returnValidator); return HCF_ERR_MALLOC; } - if (memcpy_s(returnValidator->algorithm, algoNameLen, algorithm, algoNameLen) != HCF_SUCCESS) { - LOGE("Failed to copy for validator algorithm!"); - HcfFree(returnValidator->algorithm); - returnValidator->algorithm = NULL; - HcfFree(returnValidator); - returnValidator = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(returnValidator->algorithm, algoNameLen, algorithm, algoNameLen); *pathValidator = (HcfCertChainValidator *)returnValidator; return HCF_SUCCESS; diff --git a/frameworks/certificate/x509_certificate.c b/frameworks/certificate/x509_certificate.c index b2a9034dd8ecfb6a1095567ff6735c550e36e6f7..6fac911cfdc62c107091f579f80dcde40b36940a 100644 --- a/frameworks/certificate/x509_certificate.c +++ b/frameworks/certificate/x509_certificate.c @@ -50,7 +50,7 @@ static const HcfX509CertificateFuncSet *FindAbility(const char *certType) LOGE("CertType is null!"); return NULL; } - for (uint32_t i = 0; i < sizeof(X509_CERTIFICATE_ABILITY_SET); i++) { + for (uint32_t i = 0; i < sizeof(X509_CERTIFICATE_ABILITY_SET) / sizeof(HcfCCertFactoryAbility); i++) { if (strcmp(X509_CERTIFICATE_ABILITY_SET[i].certType, certType) == 0) { return &(X509_CERTIFICATE_ABILITY_SET[i].funcSet); } @@ -70,7 +70,7 @@ static void DestroyX509Certificate(HcfObjectBase *self) return; } HcfX509CertificateImpl *impl = (HcfX509CertificateImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } @@ -130,7 +130,7 @@ static HcfResult CheckValidityWithDate(HcfX509Certificate *self, const char *dat ((HcfX509CertificateImpl *)self)->spiObj, date); } -long GetVersion(HcfX509Certificate *self) +static long GetVersion(HcfX509Certificate *self) { if (self == NULL) { LOGE("Invalid input parameter."); @@ -144,18 +144,18 @@ long GetVersion(HcfX509Certificate *self) ((HcfX509CertificateImpl *)self)->spiObj); } -long GetSerialNumber(HcfX509Certificate *self) +static HcfResult GetSerialNumber(HcfX509Certificate *self, HcfBlob *out) { if (self == NULL) { LOGE("Invalid input parameter."); - return INVALID_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetX509CertificateClass())) { LOGE("Class is not match."); - return INVALID_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } return ((HcfX509CertificateImpl *)self)->spiObj->engineGetSerialNumber( - ((HcfX509CertificateImpl *)self)->spiObj); + ((HcfX509CertificateImpl *)self)->spiObj, out); } static HcfResult GetIssuerName(HcfX509Certificate *self, HcfBlob *out) @@ -347,7 +347,6 @@ HcfResult HcfX509CertificateCreate(const HcfEncodingBlob *inStream, HcfX509Certi } const HcfX509CertificateFuncSet *funcSet = FindAbility("X509"); if (funcSet == NULL) { - LOGE("FuncSet is null!"); return HCF_NOT_SUPPORT; } HcfX509CertificateSpi *spiObj = NULL; diff --git a/frameworks/certificate/x509_crl.c b/frameworks/certificate/x509_crl.c index 152e71f221318b4e77da752955193906d0b408ae..4ed3818824c5d3b577dc0e9eba2cc0cb4e6b6762 100644 --- a/frameworks/certificate/x509_crl.c +++ b/frameworks/certificate/x509_crl.c @@ -60,7 +60,7 @@ static const HcfX509CrlFuncSet *FindAbility(const char *certType) LOGE("CertType is null!"); return NULL; } - for (uint32_t i = 0; i < sizeof(X509_CRL_ABILITY_SET); i++) { + for (uint32_t i = 0; i < sizeof(X509_CRL_ABILITY_SET) / sizeof(HcfCCertFactoryAbility); i++) { if (strcmp(X509_CRL_ABILITY_SET[i].certType, certType) == 0) { return &(X509_CRL_ABILITY_SET[i].funcSet); } @@ -80,7 +80,7 @@ static void DestroyX509Crl(HcfObjectBase *self) return; } HcfX509CrlImpl *impl = (HcfX509CrlImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } @@ -316,7 +316,6 @@ HcfResult HcfX509CrlCreate(const HcfEncodingBlob *inStream, HcfX509Crl **returnO } const HcfX509CrlFuncSet *funcSet = FindAbility("X509"); if (funcSet == NULL) { - LOGE("FuncSet is null!"); return HCF_NOT_SUPPORT; } HcfX509CrlSpi *spiObj = NULL; diff --git a/frameworks/crypto_operation/cipher.c b/frameworks/crypto_operation/cipher.c index 10cc0036d5a2e59c27b8f19e4031b53fa0268b34..65674c1a0b68b210a8d49342972412d1d132e1d9 100644 --- a/frameworks/crypto_operation/cipher.c +++ b/frameworks/crypto_operation/cipher.c @@ -16,7 +16,6 @@ #include "cipher.h" #include "aes_openssl.h" #include "config.h" -#include "aes_openssl_common.h" #include "securec.h" #include "result.h" #include "string.h" @@ -25,11 +24,11 @@ #include "cipher_rsa_openssl.h" #include "utils.h" -typedef HcfResult (*HcfCipherGeneratorSpiCreateFunc)(CipherAttr *, OH_HCF_CipherGeneratorSpi **); +typedef HcfResult (*HcfCipherGeneratorSpiCreateFunc)(CipherAttr *, HcfCipherGeneratorSpi **); typedef struct { HcfCipher super; - OH_HCF_CipherGeneratorSpi *spiObj; + HcfCipherGeneratorSpi *spiObj; char algoName[HCF_MAX_ALGO_NAME_LEN]; } CipherGenImpl; @@ -133,7 +132,7 @@ static HcfResult OnSetParameter(const HcfParaConfig *config, void *cipher) static const char *GetCipherGeneratorClass(void) { - return "OH_HCF_CipherGenerator"; + return "HcfCipherGenerator"; } const char *GetAlogrithm(HcfCipher *self) @@ -159,7 +158,7 @@ static void CipherDestroy(HcfObjectBase *self) return; } CipherGenImpl *impl = (CipherGenImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } @@ -206,7 +205,7 @@ static HcfResult CipherFinal(HcfCipher *self, HcfBlob *input, HcfBlob *output) return impl->spiObj->doFinal(impl->spiObj, input, output); } -static void InitCipher(OH_HCF_CipherGeneratorSpi *spiObj, CipherGenImpl *cipher) +static void InitCipher(HcfCipherGeneratorSpi *spiObj, CipherGenImpl *cipher) { cipher->super.init = CipherInit; cipher->super.update = CipherUpdate; @@ -222,7 +221,7 @@ static const HcfCipherGenFuncSet *FindAbility(CipherAttr *attr) return NULL; } for (uint32_t i = 0; i < sizeof(CIPHER_ABILITY_SET) / sizeof(HcfCipherGenAbility); i++) { - if (CIPHER_ABILITY_SET[i].algo == attr->algo) { + if (CIPHER_ABILITY_SET[i].algo == attr->algo) { return &(CIPHER_ABILITY_SET[i].funcSet); } } @@ -230,10 +229,10 @@ static const HcfCipherGenFuncSet *FindAbility(CipherAttr *attr) return NULL; } -HcfResult HcfCipherCreate(const char *transformation, HcfCipher **cipher) +HcfResult HcfCipherCreate(const char *transformation, HcfCipher **returnObj) { CipherAttr attr = {0}; - if (!IsStrValid(transformation, HCF_MAX_ALGO_NAME_LEN) || (cipher == NULL)) { + if (!IsStrValid(transformation, HCF_MAX_ALGO_NAME_LEN) || (returnObj == NULL)) { LOGE("Invalid input params while creating cipher!"); return HCF_INVALID_PARAMS; } @@ -257,7 +256,7 @@ HcfResult HcfCipherCreate(const char *transformation, HcfCipher **cipher) HcfFree(returnGenerator); return HCF_ERR_COPY; } - OH_HCF_CipherGeneratorSpi *spiObj = NULL; + HcfCipherGeneratorSpi *spiObj = NULL; HcfResult res = funcSet->createFunc(&attr, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); @@ -267,6 +266,6 @@ HcfResult HcfCipherCreate(const char *transformation, HcfCipher **cipher) returnGenerator->spiObj = spiObj; InitCipher(spiObj, returnGenerator); - *cipher = (HcfCipher *)returnGenerator; + *returnObj = (HcfCipher *)returnGenerator; return res; } diff --git a/frameworks/crypto_operation/key_agreement.c b/frameworks/crypto_operation/key_agreement.c index 526588ffe8a611104bc1ebb960b3a54b3d5858fa..5a49e3b6c46204caf19601b7d3648619efc72f7d 100644 --- a/frameworks/crypto_operation/key_agreement.c +++ b/frameworks/crypto_operation/key_agreement.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -38,7 +38,7 @@ typedef struct { typedef struct { HCF_ALG_VALUE algo; - HcfKeyAgreementSpiCreateFunc createSpifunc; + HcfKeyAgreementSpiCreateFunc createSpiFunc; } HcfKeyAgreementGenAbility; static const HcfKeyAgreementGenAbility KEY_AGREEMENT_GEN_ABILITY_SET[] = { @@ -49,7 +49,7 @@ static HcfKeyAgreementSpiCreateFunc FindAbility(HcfKeyAgreementParams *params) { for (uint32_t i = 0; i < sizeof(KEY_AGREEMENT_GEN_ABILITY_SET) / sizeof(KEY_AGREEMENT_GEN_ABILITY_SET[0]); i++) { if (KEY_AGREEMENT_GEN_ABILITY_SET[i].algo == params->algo) { - return KEY_AGREEMENT_GEN_ABILITY_SET[i].createSpifunc; + return KEY_AGREEMENT_GEN_ABILITY_SET[i].createSpiFunc; } } LOGE("Algo not support! [Algo]: %d", params->algo); @@ -62,7 +62,7 @@ static void SetKeyType(HCF_ALG_PARA_VALUE value, HcfKeyAgreementParams *paramsOb case HCF_ALG_ECC_224: case HCF_ALG_ECC_256: case HCF_ALG_ECC_384: - case HCF_ALG_ECC_512: + case HCF_ALG_ECC_521: paramsObj->keyLen = value; paramsObj->algo = HCF_ALG_ECC; break; @@ -132,7 +132,7 @@ static void DestroyKeyAgreement(HcfObjectBase *self) return; } HcfKeyAgreementImpl *impl = (HcfKeyAgreementImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); impl->spiObj = NULL; HcfFree(impl); } @@ -149,8 +149,8 @@ HcfResult HcfKeyAgreementCreate(const char *algoName, HcfKeyAgreement **returnOb return HCF_INVALID_PARAMS; } - HcfKeyAgreementSpiCreateFunc createSpifunc = FindAbility(¶ms); - if (createSpifunc == NULL) { + HcfKeyAgreementSpiCreateFunc createSpiFunc = FindAbility(¶ms); + if (createSpiFunc == NULL) { return HCF_NOT_SUPPORT; } @@ -165,7 +165,7 @@ HcfResult HcfKeyAgreementCreate(const char *algoName, HcfKeyAgreement **returnOb return HCF_ERR_COPY; } HcfKeyAgreementSpi *spiObj = NULL; - int32_t res = createSpifunc(¶ms, &spiObj); + int32_t res = createSpiFunc(¶ms, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnGenerator); diff --git a/frameworks/crypto_operation/mac.c b/frameworks/crypto_operation/mac.c index b94a30e0aa526b935c8457d3da3fbb54792c8396..819cec0b620c34e5aaadffe12d3bc6fe42b41017 100644 --- a/frameworks/crypto_operation/mac.c +++ b/frameworks/crypto_operation/mac.c @@ -38,7 +38,7 @@ typedef struct { typedef struct { char *algoName; - HcfMacSpiCreateFunc createSpifunc; + HcfMacSpiCreateFunc createSpiFunc; } HcfMacAbility; static const HcfMacAbility MAC_ABILITY_SET[] = { @@ -58,7 +58,7 @@ static HcfMacSpiCreateFunc FindAbility(const char *algoName) { for (uint32_t i = 0; i < (sizeof(MAC_ABILITY_SET) / sizeof(MAC_ABILITY_SET[0])); i++) { if (strcmp(MAC_ABILITY_SET[i].algoName, algoName) == 0) { - return MAC_ABILITY_SET[i].createSpifunc; + return MAC_ABILITY_SET[i].createSpiFunc; } } LOGE("Algo not support! [Algo]: %s", algoName); @@ -145,18 +145,18 @@ static void MacDestroy(HcfObjectBase *self) return; } HcfMacImpl *impl = (HcfMacImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } -HcfResult HcfMacCreate(const char *algoName, HcfMac **macApi) +HcfResult HcfMacCreate(const char *algoName, HcfMac **mac) { - if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (macApi == NULL)) { + if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (mac == NULL)) { LOGE("Invalid input params while creating mac!"); return HCF_INVALID_PARAMS; } - HcfMacSpiCreateFunc createSpifunc = FindAbility(algoName); - if (createSpifunc == NULL) { + HcfMacSpiCreateFunc createSpiFunc = FindAbility(algoName); + if (createSpiFunc == NULL) { LOGE("Algo not supported!"); return HCF_NOT_SUPPORT; } @@ -171,7 +171,7 @@ HcfResult HcfMacCreate(const char *algoName, HcfMac **macApi) return HCF_ERR_COPY; } HcfMacSpi *spiObj = NULL; - HcfResult res = createSpifunc(algoName, &spiObj); + HcfResult res = createSpiFunc(algoName, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnMacApi); @@ -185,6 +185,6 @@ HcfResult HcfMacCreate(const char *algoName, HcfMac **macApi) returnMacApi->base.getMacLength = GetMacLength; returnMacApi->base.getAlgoName = GetAlgoName; returnMacApi->spiObj = spiObj; - *macApi = (HcfMac *)returnMacApi; + *mac = (HcfMac *)returnMacApi; return HCF_SUCCESS; } \ No newline at end of file diff --git a/frameworks/crypto_operation/md.c b/frameworks/crypto_operation/md.c index b61c0a9f60206840fc9cc389100d3c542da7bd18..fdc1d453d3ceb6b5c01205952f7e6a177af25c86 100644 --- a/frameworks/crypto_operation/md.c +++ b/frameworks/crypto_operation/md.c @@ -39,7 +39,7 @@ typedef struct { typedef struct { char *algoName; - HcfMdSpiCreateFunc createSpifunc; + HcfMdSpiCreateFunc createSpiFunc; } HcfMdAbility; static const HcfMdAbility MD_ABILITY_SET[] = { @@ -60,7 +60,7 @@ static HcfMdSpiCreateFunc FindAbility(const char *algoName) { for (uint32_t i = 0; i < (sizeof(MD_ABILITY_SET) / sizeof(MD_ABILITY_SET[0])); i++) { if (strcmp(MD_ABILITY_SET[i].algoName, algoName) == 0) { - return MD_ABILITY_SET[i].createSpifunc; + return MD_ABILITY_SET[i].createSpiFunc; } } LOGE("Algo not support! [Algo]: %s", algoName); @@ -133,18 +133,18 @@ static void MdDestroy(HcfObjectBase *self) return; } HcfMdImpl *impl = (HcfMdImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } -HcfResult HcfMdCreate(const char *algoName, HcfMd **mdApi) +HcfResult HcfMdCreate(const char *algoName, HcfMd **md) { - if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (mdApi == NULL)) { + if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (md == NULL)) { LOGE("Invalid input params while creating md!"); return HCF_INVALID_PARAMS; } - HcfMdSpiCreateFunc createSpifunc = FindAbility(algoName); - if (createSpifunc == NULL) { + HcfMdSpiCreateFunc createSpiFunc = FindAbility(algoName); + if (createSpiFunc == NULL) { LOGE("Algo not supported!"); return HCF_NOT_SUPPORT; } @@ -159,7 +159,7 @@ HcfResult HcfMdCreate(const char *algoName, HcfMd **mdApi) return HCF_ERR_COPY; } HcfMdSpi *spiObj = NULL; - HcfResult res = createSpifunc(algoName, &spiObj); + HcfResult res = createSpiFunc(algoName, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnMdApi); @@ -172,6 +172,6 @@ HcfResult HcfMdCreate(const char *algoName, HcfMd **mdApi) returnMdApi->base.getMdLength = GetMdLength; returnMdApi->base.getAlgoName = GetAlgoName; returnMdApi->spiObj = spiObj; - *mdApi = (HcfMd *)returnMdApi; + *md = (HcfMd *)returnMdApi; return HCF_SUCCESS; } \ No newline at end of file diff --git a/frameworks/crypto_operation/signature.c b/frameworks/crypto_operation/signature.c index 5ba115677ea58f55b907a5d61628776200018570..d5fbedf807f7df494c3de4d95fecdf1cd8d66860 100644 --- a/frameworks/crypto_operation/signature.c +++ b/frameworks/crypto_operation/signature.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -95,7 +95,7 @@ static void SetKeyType(HCF_ALG_PARA_VALUE value, HcfSignatureParams *paramsObj) case HCF_ALG_ECC_224: case HCF_ALG_ECC_256: case HCF_ALG_ECC_384: - case HCF_ALG_ECC_512: + case HCF_ALG_ECC_521: paramsObj->keyLen = value; paramsObj->algo = HCF_ALG_ECC; break; @@ -185,7 +185,7 @@ static void DestroySign(HcfObjectBase *self) return; } HcfSignImpl *impl = (HcfSignImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); impl->spiObj = NULL; HcfFree(impl); } @@ -199,7 +199,7 @@ static void DestroyVerify(HcfObjectBase *self) return; } HcfVerifyImpl *impl = (HcfVerifyImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); impl->spiObj = NULL; HcfFree(impl); } @@ -294,8 +294,8 @@ HcfResult HcfSignCreate(const char *algoName, HcfSign **returnObj) return HCF_INVALID_PARAMS; } - HcfSignSpiCreateFunc createSpifunc = FindSignAbility(¶ms); - if (createSpifunc == NULL) { + HcfSignSpiCreateFunc createSpiFunc = FindSignAbility(¶ms); + if (createSpiFunc == NULL) { LOGE("Can not find ability."); return HCF_NOT_SUPPORT; } @@ -311,7 +311,7 @@ HcfResult HcfSignCreate(const char *algoName, HcfSign **returnObj) return HCF_ERR_COPY; } HcfSignSpi *spiObj = NULL; - int32_t res = createSpifunc(¶ms, &spiObj); + int32_t res = createSpiFunc(¶ms, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnSign); @@ -342,8 +342,8 @@ HcfResult HcfVerifyCreate(const char *algoName, HcfVerify **returnObj) return HCF_INVALID_PARAMS; } - HcfVerifySpiCreateFunc createSpifunc = FindVerifyAbility(¶ms); - if (createSpifunc == NULL) { + HcfVerifySpiCreateFunc createSpiFunc = FindVerifyAbility(¶ms); + if (createSpiFunc == NULL) { return HCF_NOT_SUPPORT; } @@ -358,7 +358,7 @@ HcfResult HcfVerifyCreate(const char *algoName, HcfVerify **returnObj) return HCF_ERR_COPY; } HcfVerifySpi *spiObj = NULL; - int32_t res = createSpifunc(¶ms, &spiObj); + int32_t res = createSpiFunc(¶ms, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnVerify); diff --git a/frameworks/frameworks.gni b/frameworks/frameworks.gni index bb71e2712629f3d2ea3b8cec6db3b50a7662671a..af458e2cdae018bf8c98cd47f9df3e55bd4e2d6c 100644 --- a/frameworks/frameworks.gni +++ b/frameworks/frameworks.gni @@ -23,7 +23,6 @@ framework_inc_path = [ "${base_path}/interfaces/innerkits/key", "${base_path}/interfaces/innerkits/rand", "${base_path}/common/inc", - "${plugin_path}/openssl_plugin/aes/inc", "${plugin_path}/openssl_plugin/certificate/inc", "${plugin_path}/openssl_plugin/crypto_operation/key_agreement/inc", "${plugin_path}/openssl_plugin/crypto_operation/signature/inc", diff --git a/frameworks/js/napi/certificate/BUILD.gn b/frameworks/js/napi/certificate/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..09b30501e2a14f138f942aaa93a40e705171956b --- /dev/null +++ b/frameworks/js/napi/certificate/BUILD.gn @@ -0,0 +1,64 @@ +# Copyright (C) 2022 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/ohos.gni") + +ohos_shared_library("cert_napi") { + subsystem_name = "security" + part_name = "crypto_framework" + relative_install_dir = "module/security" + include_dirs = [ + "//third_party/bounds_checking_function/include", + "//commonlibrary/c_utils/base/include", + "//base/security/crypto_framework/frameworks/js/napi/certificate/inc", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + ] + include_dirs += framework_inc_path + + if (os_level == "standard") { + sanitize = { + cfi = true + debug = false + blocklist = "//base/security/crypto_framework/cfi_blocklist.txt" + } + } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-g3", + ] + + sources = [ + "src/napi_cert_chain_validator.cpp", + "src/napi_cert_utils.cpp", + "src/napi_certificate_init.cpp", + "src/napi_key.cpp", + "src/napi_pub_key.cpp", + "src/napi_x509_certificate.cpp", + "src/napi_x509_crl.cpp", + "src/napi_x509_crl_entry.cpp", + ] + + deps = [ + "//base/security/crypto_framework/frameworks:crypto_framework_lib", + "//third_party/bounds_checking_function:libsec_shared", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "napi:ace_napi", + ] +} diff --git a/frameworks/js/napi/inc/napi_cert_chain_validator.h b/frameworks/js/napi/certificate/inc/napi_cert_chain_validator.h similarity index 88% rename from frameworks/js/napi/inc/napi_cert_chain_validator.h rename to frameworks/js/napi/certificate/inc/napi_cert_chain_validator.h index b31d7cf657c9385ac2f92b2acbe96b35642615fb..a58c2afba3d8e7cc74179a871d8e419783e0ae6e 100644 --- a/frameworks/js/napi/inc/napi_cert_chain_validator.h +++ b/frameworks/js/napi/certificate/inc/napi_cert_chain_validator.h @@ -23,10 +23,10 @@ #include "cert_chain_validator.h" namespace OHOS { -namespace CryptoFramework { +namespace CertFramework { class NapiCertChainValidator { public: - NapiCertChainValidator(HcfCertChainValidator *certChainValidator); + explicit NapiCertChainValidator(HcfCertChainValidator *certChainValidator); ~NapiCertChainValidator(); static void DefineCertChainValidatorJSClass(napi_env env, napi_value exports); @@ -39,12 +39,12 @@ public: return certChainValidator_; } - static napi_ref classRef_; + static thread_local napi_ref classRef_; private: HcfCertChainValidator *certChainValidator_ = nullptr; }; -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS #endif // NAPI_CERT_CHAIN_VALIDATOR_H diff --git a/frameworks/js/napi/certificate/inc/napi_cert_defines.h b/frameworks/js/napi/certificate/inc/napi_cert_defines.h new file mode 100644 index 0000000000000000000000000000000000000000..dbf22e4f88627d87aae2959aa2a192d6ee848124 --- /dev/null +++ b/frameworks/js/napi/certificate/inc/napi_cert_defines.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 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 NAPI_CERT_DEFINES_H +#define NAPI_CERT_DEFINES_H + +#include + +namespace OHOS { +namespace CertFramework { +constexpr size_t ARGS_SIZE_ONE = 1; +constexpr size_t ARGS_SIZE_TWO = 2; +constexpr size_t ARGS_SIZE_THREE = 3; +constexpr size_t ARGS_SIZE_FOUR = 4; +constexpr int32_t PARAM0 = 0; +constexpr int32_t PARAM1 = 1; +constexpr int32_t PARAM2 = 2; +constexpr uint32_t JS_ERR_DEFAULT_ERR = 0; +constexpr uint32_t MAX_SN_BYTE_CNT = 100; +constexpr uint32_t QUAD_WORD_ALIGN_UP = 3; + +constexpr uint32_t JS_ERR_CERT_INVALID_PARAMS = 401; +constexpr uint32_t JS_ERR_CERT_NOT_SUPPORT = 801; +constexpr uint32_t JS_ERR_CERT_OUT_OF_MEMORY = 19020001; +constexpr uint32_t JS_ERR_CERT_RUNTIME_ERROR = 19020002; +constexpr uint32_t JS_ERR_CERT_CRYPTO_OPERATION = 19030001; +constexpr uint32_t JS_ERR_CERT_SIGNATURE_FAILURE = 19030002; +constexpr uint32_t JS_ERR_CERT_NOT_YET_VALID = 19030003; +constexpr uint32_t JS_ERR_CERT_HAS_EXPIRED = 19030004; +constexpr uint32_t JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 19030005; +constexpr uint32_t JS_ERR_KEYUSAGE_NO_CERTSIGN = 19030006; +constexpr uint32_t JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = 19030007; + +const std::string CERT_TAG_DATA = "data"; +const std::string CERT_TAG_ERR_CODE = "code"; +const std::string CERT_TAG_COUNT = "count"; +const std::string CERT_TAG_ENCODING_FORMAT = "encodingFormat"; +const std::string CERT_TAG_ALGORITHM = "algorithm"; +const std::string CRYPTO_TAG_ALG_NAME = "algName"; +const std::string CRYPTO_TAG_FORMAT = "format"; + +enum CertAsyncType { + CERT_ASYNC_TYPE_CALLBACK = 1, + CERT_ASYNC_TYPE_PROMISE = 2 +}; +} // namespace CertFramework +} // namespace OHOS + +#endif // NAPI_CERT_DEFINES_H diff --git a/frameworks/js/napi/certificate/inc/napi_cert_utils.h b/frameworks/js/napi/certificate/inc/napi_cert_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..4d4d258f7dac6cc5b474903365a9e7b42ba82878 --- /dev/null +++ b/frameworks/js/napi/certificate/inc/napi_cert_utils.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2023 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 NAPI_CERT_UILTS_H +#define NAPI_CERT_UILTS_H + +#include +#include +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "blob.h" +#include "cert_chain_validator.h" + +namespace OHOS { +namespace CertFramework { +inline void CertAddUint32Property(napi_env env, napi_value object, const char *name, uint32_t value) +{ + napi_value property = nullptr; + napi_create_uint32(env, value, &property); + napi_set_named_property(env, object, name, property); +} + +HcfBlob *CertGetBlobFromNapiValue(napi_env env, napi_value arg); +napi_value CertConvertBlobToNapiValue(napi_env env, HcfBlob *blob); + +bool CertGetStringFromJSParams(napi_env env, napi_value arg, std::string &returnStr); +bool CertGetInt32FromJSParams(napi_env env, napi_value arg, int32_t &returnInt); +bool CertGetCallbackFromJSParams(napi_env env, napi_value arg, napi_ref *returnCb); +bool GetEncodingBlobFromValue(napi_env env, napi_value object, HcfEncodingBlob **encodingBlob); +bool GetCertChainFromValue(napi_env env, napi_value object, HcfCertChainData **certChainData); +bool CertCheckArgsCount(napi_env env, size_t argc, size_t expectedCount, bool isSync); +napi_value CertGetResourceName(napi_env env, const char *name); +napi_value GenerateArrayBuffer(napi_env env, uint8_t *data, uint32_t size); +napi_value CertNapiGetNull(napi_env env); +napi_value ConvertArrayToNapiValue(napi_env env, HcfArray *array); +napi_value ConvertEncodingBlobToNapiValue(napi_env env, HcfEncodingBlob *encodingBlob); +napi_value CertGenerateBusinessError(napi_env env, int32_t errCode, const char *errMsg); +napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob); +napi_value ConvertBlobToBigIntWords(napi_env env, const HcfBlob &blob); +} // namespace CertFramework +} // namespace OHOS +#endif diff --git a/frameworks/js/napi/certificate/inc/napi_key.h b/frameworks/js/napi/certificate/inc/napi_key.h new file mode 100644 index 0000000000000000000000000000000000000000..674933439e10101dcec14459b94b8dd5cd432543 --- /dev/null +++ b/frameworks/js/napi/certificate/inc/napi_key.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2023 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 CF_NAPI_KEY_H +#define CF_NAPI_KEY_H + +#include +#include "log.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "key.h" + +namespace OHOS { +namespace CertFramework { +class NapiKey { +public: + explicit NapiKey(HcfKey *hcfKey); + virtual ~NapiKey(); + HcfKey *GetHcfKey() const; + + static void DefineHcfKeyJSClass(napi_env env); + static napi_value KeyConstructor(napi_env env, napi_callback_info info); + + static napi_value JsGetAlgorithm(napi_env env, napi_callback_info info); + static napi_value JsGetEncoded(napi_env env, napi_callback_info info); + static napi_value JsGetFormat(napi_env env, napi_callback_info info); + + static thread_local napi_ref classRef_; +protected: + HcfKey *hcfKey_; +}; +} // namespace CertFramework +} // namespace OHOS +#endif diff --git a/frameworks/js/napi/certificate/inc/napi_pub_key.h b/frameworks/js/napi/certificate/inc/napi_pub_key.h new file mode 100644 index 0000000000000000000000000000000000000000..45ef2c3e4ce9d82ac58c078b9c6c2874bdec5d44 --- /dev/null +++ b/frameworks/js/napi/certificate/inc/napi_pub_key.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2023 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 CF_NAPI_PUB_KEY_H +#define CF_NAPI_PUB_KEY_H + +#include +#include "log.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "pub_key.h" +#include "napi_key.h" + +namespace OHOS { +namespace CertFramework { +class NapiPubKey : public NapiKey { +public: + explicit NapiPubKey(HcfPubKey *pubKey); + ~NapiPubKey() override; + + HcfPubKey *GetPubKey(); + napi_value ConvertToJsPubKey(napi_env env); + + static void DefinePubKeyJSClass(napi_env env); + static napi_value PubKeyConstructor(napi_env env, napi_callback_info info); + + static napi_value JsGetEncoded(napi_env env, napi_callback_info info); + + static thread_local napi_ref classRef_; +}; +} // namespace CertFramework +} // namespace OHOS +#endif diff --git a/frameworks/js/napi/inc/napi_x509_certificate.h b/frameworks/js/napi/certificate/inc/napi_x509_certificate.h similarity index 94% rename from frameworks/js/napi/inc/napi_x509_certificate.h rename to frameworks/js/napi/certificate/inc/napi_x509_certificate.h index 1200e809164a2be8a995bc5bd7cb69815f2a431b..7b69c4681bde397f010450186a88ef54d10f367d 100644 --- a/frameworks/js/napi/inc/napi_x509_certificate.h +++ b/frameworks/js/napi/certificate/inc/napi_x509_certificate.h @@ -23,10 +23,10 @@ #include "x509_certificate.h" namespace OHOS { -namespace CryptoFramework { +namespace CertFramework { class NapiX509Certificate { public: - NapiX509Certificate(HcfX509Certificate *x509Cert); + explicit NapiX509Certificate(HcfX509Certificate *x509Cert); ~NapiX509Certificate(); static void DefineX509CertJSClass(napi_env env, napi_value exports); @@ -62,12 +62,12 @@ public: return x509Cert_; } - static napi_ref classRef_; + static thread_local napi_ref classRef_; private: HcfX509Certificate *x509Cert_ = nullptr; }; -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS #endif // NAPI_X509_CERTIFICATE_H diff --git a/frameworks/js/napi/inc/napi_x509_crl.h b/frameworks/js/napi/certificate/inc/napi_x509_crl.h similarity index 94% rename from frameworks/js/napi/inc/napi_x509_crl.h rename to frameworks/js/napi/certificate/inc/napi_x509_crl.h index fdc0c7c0bd148a215106f88e5b858401827e9e6a..cce8bcd7be6840956e447b94465f1ed1fe2ef884 100644 --- a/frameworks/js/napi/inc/napi_x509_crl.h +++ b/frameworks/js/napi/certificate/inc/napi_x509_crl.h @@ -23,10 +23,10 @@ #include "x509_crl.h" namespace OHOS { -namespace CryptoFramework { +namespace CertFramework { class NapiX509Crl { public: - NapiX509Crl(HcfX509Crl *x509Crl); + explicit NapiX509Crl(HcfX509Crl *x509Crl); ~NapiX509Crl(); static void DefineX509CrlJSClass(napi_env env, napi_value exports); @@ -57,12 +57,12 @@ public: return x509Crl_; } - static napi_ref classRef_; + static thread_local napi_ref classRef_; private: HcfX509Crl *x509Crl_ = nullptr; }; -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS #endif // NAPI_X509_CRL_H diff --git a/frameworks/js/napi/inc/napi_x509_crl_entry.h b/frameworks/js/napi/certificate/inc/napi_x509_crl_entry.h similarity index 90% rename from frameworks/js/napi/inc/napi_x509_crl_entry.h rename to frameworks/js/napi/certificate/inc/napi_x509_crl_entry.h index 6a80a98574dcf185b4f02e6cbcbeac7b79f796e9..2d8f97e8341a347b7a82621a133ea6237277d0a2 100644 --- a/frameworks/js/napi/inc/napi_x509_crl_entry.h +++ b/frameworks/js/napi/certificate/inc/napi_x509_crl_entry.h @@ -23,10 +23,10 @@ #include "x509_crl_entry.h" namespace OHOS { -namespace CryptoFramework { +namespace CertFramework { class NapiX509CrlEntry { public: - NapiX509CrlEntry(HcfX509CrlEntry *x509CrlEntry); + explicit NapiX509CrlEntry(HcfX509CrlEntry *x509CrlEntry); ~NapiX509CrlEntry(); static void DefineX509CrlEntryJSClass(napi_env env); @@ -43,12 +43,12 @@ public: return x509CrlEntry_; } - static napi_ref classRef_; + static thread_local napi_ref classRef_; private: HcfX509CrlEntry *x509CrlEntry_ = nullptr; }; -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS #endif // NAPI_X509_CRL_ENTRY_H diff --git a/frameworks/js/napi/src/napi_cert_chain_validator.cpp b/frameworks/js/napi/certificate/src/napi_cert_chain_validator.cpp similarity index 81% rename from frameworks/js/napi/src/napi_cert_chain_validator.cpp rename to frameworks/js/napi/certificate/src/napi_cert_chain_validator.cpp index d87e1955c70c8ed0ec89b524ba8ebd4e45f3ad88..84b6be819fef210a44e06e4bc91db57887773514 100644 --- a/frameworks/js/napi/src/napi_cert_chain_validator.cpp +++ b/frameworks/js/napi/certificate/src/napi_cert_chain_validator.cpp @@ -22,15 +22,15 @@ #include "utils.h" #include "result.h" #include "object_base.h" -#include "napi_crypto_framework_defines.h" -#include "napi_utils.h" +#include "napi_cert_defines.h" +#include "napi_cert_utils.h" namespace OHOS { -namespace CryptoFramework { -napi_ref NapiCertChainValidator::classRef_ = nullptr; +namespace CertFramework { +thread_local napi_ref NapiCertChainValidator::classRef_ = nullptr; struct CfCtx { - CfAsyncType asyncType = ASYNC_TYPE_CALLBACK; + CertAsyncType asyncType = CERT_ASYNC_TYPE_CALLBACK; napi_ref callback = nullptr; napi_deferred deferred = nullptr; napi_async_work asyncWork = nullptr; @@ -49,7 +49,7 @@ NapiCertChainValidator::NapiCertChainValidator(HcfCertChainValidator *certChainV NapiCertChainValidator::~NapiCertChainValidator() { - OH_HCF_OBJ_DESTROY(this->certChainValidator_); + HcfObjDestroy(this->certChainValidator_); } static void FreeCryptoFwkCtx(napi_env env, CfCtx *context) @@ -80,7 +80,7 @@ static void ReturnCallbackResult(napi_env env, CfCtx *context, napi_value result { napi_value businessError = nullptr; if (context->errCode != HCF_SUCCESS) { - businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + businessError = CertGenerateBusinessError(env, context->errCode, context->errMsg); } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; @@ -98,13 +98,14 @@ static void ReturnPromiseResult(napi_env env, CfCtx *context, napi_value result) if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + CertGenerateBusinessError(env, context->errCode, context->errMsg)); } } static void ReturnResult(napi_env env, CfCtx *context, napi_value result) { - if (context->asyncType == ASYNC_TYPE_CALLBACK) { + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { ReturnCallbackResult(env, context, result); } else { ReturnPromiseResult(env, context, result); @@ -125,17 +126,17 @@ static void ValidateExecute(napi_env env, void *data) static void ValidateComplete(napi_env env, napi_status status, void *data) { CfCtx *context = static_cast(data); - ReturnResult(env, context, NapiGetNull(env)); + ReturnResult(env, context, CertNapiGetNull(env)); FreeCryptoFwkCtx(env, context); } napi_value NapiCertChainValidator::Validate(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); @@ -145,15 +146,15 @@ napi_value NapiCertChainValidator::Validate(napi_env env, napi_callback_info inf } context->ccvClass = this; - context->asyncType = (argc == ARGS_SIZE_TWO) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE; + context->asyncType = (argc == ARGS_SIZE_TWO) ? CERT_ASYNC_TYPE_CALLBACK : CERT_ASYNC_TYPE_PROMISE; if (!GetCertChainFromValue(env, argv[PARAM0], &context->certChainData)) { LOGE("get cert chain data from napi value failed!"); FreeCryptoFwkCtx(env, context); return nullptr; } napi_value promise = nullptr; - if (context->asyncType == ASYNC_TYPE_CALLBACK) { - if (!GetCallbackFromJSParams(env, argv[PARAM1], &context->callback)) { + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { + if (!CertGetCallbackFromJSParams(env, argv[PARAM1], &context->callback)) { LOGE("get callback failed!"); FreeCryptoFwkCtx(env, context); return nullptr; @@ -163,17 +164,17 @@ napi_value NapiCertChainValidator::Validate(napi_env env, napi_callback_info inf } napi_create_async_work( - env, nullptr, GetResourceName(env, "Validate"), + env, nullptr, CertGetResourceName(env, "Validate"), ValidateExecute, ValidateComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } @@ -203,24 +204,24 @@ napi_value NapiCertChainValidator::CreateCertChainValidator(napi_env env, napi_c LOGI("start to create cert chain validator."); napi_value thisVar = nullptr; size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != ARGS_SIZE_ONE) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "invalid params count")); + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "invalid params count")); LOGE("invalid params count!"); return nullptr; } std::string algorithm; - if (!GetStringFromJSParams(env, argv[PARAM0], algorithm)) { + if (!CertGetStringFromJSParams(env, argv[PARAM0], algorithm)) { LOGE("Failed to get algorithm."); return nullptr; } HcfCertChainValidator *certChainValidator = nullptr; HcfResult res = HcfCertChainValidatorCreate(algorithm.c_str(), &certChainValidator); if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "create cert chain validator failed")); + napi_throw(env, CertGenerateBusinessError(env, res, "create cert chain validator failed")); LOGE("Failed to create c cert chain validator."); return nullptr; } @@ -231,12 +232,12 @@ napi_value NapiCertChainValidator::CreateCertChainValidator(napi_env env, napi_c napi_value validatorInstance = nullptr; napi_get_reference_value(env, classRef_, &constructor); napi_new_instance(env, constructor, 0, nullptr, &validatorInstance); - napi_set_named_property(env, validatorInstance, CRYPTO_TAG_ALGORITHM.c_str(), algValue); + napi_set_named_property(env, validatorInstance, CERT_TAG_ALGORITHM.c_str(), algValue); NapiCertChainValidator *ccvClass = new NapiCertChainValidator(certChainValidator); napi_wrap( env, validatorInstance, ccvClass, [](napi_env env, void* data, void *hint) { - NapiCertChainValidator *ccv = (NapiCertChainValidator *)data; + NapiCertChainValidator *ccv = static_cast(data); delete ccv; }, nullptr, @@ -260,5 +261,5 @@ void NapiCertChainValidator::DefineCertChainValidatorJSClass(napi_env env, napi_ sizeof(validatorDesc) / sizeof(validatorDesc[0]), validatorDesc, &constructor); napi_create_reference(env, constructor, 1, &classRef_); } -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/certificate/src/napi_cert_utils.cpp b/frameworks/js/napi/certificate/src/napi_cert_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0f2e57cc7ceca54194265d3b78df7bcac4f2f843 --- /dev/null +++ b/frameworks/js/napi/certificate/src/napi_cert_utils.cpp @@ -0,0 +1,574 @@ +/* + * Copyright (C) 2023 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 "napi_cert_utils.h" + +#include "log.h" +#include "memory.h" +#include "securec.h" +#include "cipher.h" +#include "napi_cert_defines.h" +#include "detailed_iv_params.h" +#include "detailed_gcm_params.h" +#include "detailed_ccm_params.h" + +namespace OHOS { +namespace CertFramework { +using namespace std; +napi_value CertNapiGetNull(napi_env env) +{ + napi_value result = nullptr; + napi_get_null(env, &result); + return result; +} + +napi_value ConvertArrayToNapiValue(napi_env env, HcfArray *array) +{ + if (array == nullptr) { + LOGE("array is null!"); + return nullptr; + } + if (array->count == 0) { + LOGE("array count is 0!"); + return nullptr; + } + napi_value returnArray = nullptr; + napi_create_array(env, &returnArray); + if (returnArray == nullptr) { + LOGE("create return array failed!"); + return nullptr; + } + for (uint32_t i = 0; i < array->count; i++) { + HcfBlob *blob = reinterpret_cast(array->data + i); + napi_value outBuffer = GenerateArrayBuffer(env, blob->data, blob->len); + if (outBuffer == nullptr) { + LOGE("generate array buffer failed!"); + return nullptr; + } + napi_value element = nullptr; + napi_create_typedarray(env, napi_uint8_array, blob->len, outBuffer, 0, &element); + napi_set_element(env, returnArray, i, element); + } + napi_value returnValue = nullptr; + napi_create_object(env, &returnValue); + napi_set_named_property(env, returnValue, CERT_TAG_DATA.c_str(), returnArray); + return returnValue; +} + +napi_value GenerateArrayBuffer(napi_env env, uint8_t *data, uint32_t size) +{ + uint8_t *buffer = static_cast(HcfMalloc(size, 0)); + if (buffer == nullptr) { + LOGE("malloc uint8 array buffer failed!"); + return nullptr; + } + + if (memcpy_s(buffer, size, data, size) != EOK) { + LOGE("memcpy_s data to buffer failed!"); + HcfFree(buffer); + return nullptr; + } + + napi_value outBuffer = nullptr; + napi_status status = napi_create_external_arraybuffer( + env, buffer, size, [](napi_env env, void *data, void *hint) { HcfFree(data); }, nullptr, &outBuffer); + if (status != napi_ok) { + LOGE("create uint8 array buffer failed!"); + HcfFree(buffer); + return nullptr; + } + buffer = nullptr; + return outBuffer; +} + +static bool GetDataOfEncodingBlob(napi_env env, napi_value data, HcfEncodingBlob *encodingBlob) +{ + napi_typedarray_type arrayType; + napi_value arrayBuffer = nullptr; + size_t length = 0; + size_t offset = 0; + void *rawData = nullptr; + + napi_status status = napi_get_typedarray_info(env, data, &arrayType, &length, + reinterpret_cast(&rawData), &arrayBuffer, &offset); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get array data failed")); + LOGE("failed to get array data!"); + return false; + } + if (arrayType != napi_uint8_array) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "array type is not uint8 array")); + LOGE("array is not uint8 array!"); + return false; + } + + if (length == 0) { + LOGE("input data length is 0"); + return false; + } + encodingBlob->data = static_cast(HcfMalloc(length, 0)); + if (encodingBlob->data == nullptr) { + LOGE("malloc encoding blob data failed!"); + return false; + } + if (memcpy_s(encodingBlob->data, length, rawData, length) != EOK) { + LOGE("memcpy_s encoding blob data failed!"); + HcfFree(encodingBlob->data); + encodingBlob->data = nullptr; + return false; + } + encodingBlob->len = length; + return true; +} + +bool GetEncodingBlobFromValue(napi_env env, napi_value obj, HcfEncodingBlob **encodingBlob) +{ + *encodingBlob = static_cast(HcfMalloc(sizeof(HcfEncodingBlob), 0)); + if (*encodingBlob == nullptr) { + LOGE("malloc encoding blob failed!"); + return false; + } + napi_value data = nullptr; + napi_status status = napi_get_named_property(env, obj, CERT_TAG_DATA.c_str(), &data); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get encoding blob data failed")); + LOGE("failed to get encoding blob data!"); + HcfFree(*encodingBlob); + *encodingBlob = nullptr; + return false; + } + if (!GetDataOfEncodingBlob(env, data, *encodingBlob)) { + HcfFree(*encodingBlob); + *encodingBlob = nullptr; + return false; + } + napi_value format = nullptr; + status = napi_get_named_property(env, obj, CERT_TAG_ENCODING_FORMAT.c_str(), &format); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get encoding blob format failed")); + LOGE("failed to get encoding blob format!"); + HcfFree((*encodingBlob)->data); + (*encodingBlob)->data = nullptr; + HcfFree(*encodingBlob); + *encodingBlob = nullptr; + return false; + } + napi_get_value_uint32(env, format, reinterpret_cast(&(*encodingBlob)->encodingFormat)); + return true; +} + +napi_value ConvertEncodingBlobToNapiValue(napi_env env, HcfEncodingBlob *encodingBlob) +{ + napi_value outBuffer = GenerateArrayBuffer(env, encodingBlob->data, encodingBlob->len); + if (outBuffer == nullptr) { + LOGE("generate array buffer failed!"); + return nullptr; + } + napi_value outData = nullptr; + napi_create_typedarray(env, napi_uint8_array, encodingBlob->len, outBuffer, 0, &outData); + napi_value encoding = nullptr; + napi_create_uint32(env, encodingBlob->encodingFormat, &encoding); + napi_value returnEncodingBlob = nullptr; + napi_create_object(env, &returnEncodingBlob); + napi_set_named_property(env, returnEncodingBlob, CERT_TAG_DATA.c_str(), outData); + napi_set_named_property(env, returnEncodingBlob, CERT_TAG_ENCODING_FORMAT.c_str(), encoding); + return returnEncodingBlob; +} + +HcfBlob *CertGetBlobFromNapiValue(napi_env env, napi_value arg) +{ + if ((env == nullptr) || (arg == nullptr)) { + LOGE("Invalid parmas!"); + return nullptr; + } + napi_value data = nullptr; + napi_status status = napi_get_named_property(env, arg, CERT_TAG_DATA.c_str(), &data); + if ((status != napi_ok) || (data == nullptr)) { + LOGE("failed to get valid data property!"); + return nullptr; + } + + size_t length = 0; + size_t offset = 0; + void *rawData = nullptr; + napi_value arrayBuffer = nullptr; + napi_typedarray_type arrayType; + // Warning: Do not release the rawData returned by this interface because the rawData is managed by VM. + status = napi_get_typedarray_info(env, data, &arrayType, &length, + reinterpret_cast(&rawData), &arrayBuffer, &offset); + if ((status != napi_ok) || (length == 0) || (rawData == nullptr)) { + LOGE("failed to get valid rawData."); + return nullptr; + } + if (arrayType != napi_uint8_array) { + LOGE("input data is not uint8 array."); + return nullptr; + } + + HcfBlob *newBlob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); + if (newBlob == nullptr) { + LOGE("Failed to allocate newBlob memory!"); + return nullptr; + } + newBlob->len = length; + newBlob->data = static_cast(HcfMalloc(length, 0)); + if (newBlob->data == nullptr) { + LOGE("malloc blob data failed!"); + HcfFree(newBlob); + return nullptr; + } + if (memcpy_s(newBlob->data, length, rawData, length) != EOK) { + LOGE("memcpy_s blob data failed!"); + HcfFree(newBlob->data); + HcfFree(newBlob); + return nullptr; + } + + return newBlob; +} + +napi_value CertConvertBlobToNapiValue(napi_env env, HcfBlob *blob) +{ + if (blob == nullptr || blob->data == nullptr || blob->len == 0) { + LOGE("Invalid blob!"); + return nullptr; + } + uint8_t *buffer = static_cast(HcfMalloc(blob->len, 0)); + if (buffer == nullptr) { + LOGE("malloc uint8 array buffer failed!"); + return nullptr; + } + + if (memcpy_s(buffer, blob->len, blob->data, blob->len) != EOK) { + LOGE("memcpy_s data to buffer failed!"); + HcfFree(buffer); + return nullptr; + } + + napi_value outBuffer = nullptr; + napi_status status = napi_create_external_arraybuffer( + env, buffer, blob->len, [](napi_env env, void *data, void *hint) { HcfFree(data); }, nullptr, &outBuffer); + if (status != napi_ok) { + LOGE("create uint8 array buffer failed!"); + HcfFree(buffer); + return nullptr; + } + buffer = nullptr; + + napi_value outData = nullptr; + napi_create_typedarray(env, napi_uint8_array, blob->len, outBuffer, 0, &outData); + napi_value dataBlob = nullptr; + napi_create_object(env, &dataBlob); + napi_set_named_property(env, dataBlob, CERT_TAG_DATA.c_str(), outData); + + return dataBlob; +} + +static bool GetDataOfCertChain(napi_env env, napi_value data, HcfCertChainData *certChain) +{ + napi_typedarray_type arrayType; + napi_value arrayBuffer = nullptr; + size_t length = 0; + size_t offset = 0; + void *rawData = nullptr; + + napi_status status = napi_get_typedarray_info(env, data, &arrayType, &length, + reinterpret_cast(&rawData), &arrayBuffer, &offset); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get array data failed")); + LOGE("failed to get array data!"); + return false; + } + if (arrayType != napi_uint8_array) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "array type is not uint8 array")); + LOGE("array is not uint8 array!"); + return false; + } + + if (length == 0) { + LOGE("input data length is 0"); + return false; + } + certChain->data = static_cast(HcfMalloc(length, 0)); + if (certChain->data == nullptr) { + LOGE("malloc cert chain data failed!"); + return false; + } + if (memcpy_s(certChain->data, length, rawData, length) != EOK) { + LOGE("memcpy_s cert chain data failed!"); + HcfFree(certChain->data); + certChain->data = nullptr; + return false; + } + certChain->dataLen = length; + return true; +} + +bool GetCertChainFromValue(napi_env env, napi_value obj, HcfCertChainData **certChainData) +{ + *certChainData = static_cast(HcfMalloc(sizeof(HcfCertChainData), 0)); + if (*certChainData == nullptr) { + LOGE("malloc certChainData failed!"); + return false; + } + napi_value data = nullptr; + napi_status status = napi_get_named_property(env, obj, CERT_TAG_DATA.c_str(), &data); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain data failed")); + LOGE("failed to get cert chain data!"); + HcfFree(*certChainData); + *certChainData = nullptr; + return false; + } + if (!GetDataOfCertChain(env, data, *certChainData)) { + HcfFree(*certChainData); + *certChainData = nullptr; + return false; + } + + napi_value certCount = nullptr; + status = napi_get_named_property(env, obj, CERT_TAG_COUNT.c_str(), &certCount); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain count failed")); + LOGE("failed to get cert count!"); + HcfFree((*certChainData)->data); + (*certChainData)->data = nullptr; + HcfFree(*certChainData); + *certChainData = nullptr; + return false; + } + napi_get_value_uint32(env, certCount, reinterpret_cast(&(*certChainData)->count)); + + napi_value format = nullptr; + status = napi_get_named_property(env, obj, CERT_TAG_ENCODING_FORMAT.c_str(), &format); + if (status != napi_ok) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain format failed")); + LOGE("failed to get cert chain format!"); + HcfFree((*certChainData)->data); + (*certChainData)->data = nullptr; + HcfFree(*certChainData); + *certChainData = nullptr; + return false; + } + napi_get_value_uint32(env, format, reinterpret_cast(&(*certChainData)->format)); + return true; +} + +bool CertGetStringFromJSParams(napi_env env, napi_value arg, string &returnStr) +{ + napi_valuetype valueType; + napi_typeof(env, arg, &valueType); + if (valueType != napi_string) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "param type is not string")); + LOGE("wrong argument type. expect string type. [Type]: %d", valueType); + return false; + } + + size_t length = 0; + if (napi_get_value_string_utf8(env, arg, nullptr, 0, &length) != napi_ok) { + LOGE("can not get string length"); + return false; + } + returnStr.reserve(length + 1); + returnStr.resize(length); + if (napi_get_value_string_utf8(env, arg, returnStr.data(), (length + 1), &length) != napi_ok) { + LOGE("can not get string value"); + return false; + } + return true; +} + +bool CertGetInt32FromJSParams(napi_env env, napi_value arg, int32_t &returnInt) +{ + napi_valuetype valueType; + napi_typeof(env, arg, &valueType); + if (valueType != napi_number) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "param type is not number")); + LOGE("wrong argument type. expect int type. [Type]: %d", valueType); + return false; + } + + if (napi_get_value_int32(env, arg, &returnInt) != napi_ok) { + LOGE("can not get int value"); + return false; + } + return true; +} + +bool CertGetCallbackFromJSParams(napi_env env, napi_value arg, napi_ref *returnCb) +{ + napi_valuetype valueType = napi_undefined; + napi_typeof(env, arg, &valueType); + if (valueType != napi_function) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "param type is not function")); + LOGE("wrong argument type. expect callback type. [Type]: %d", valueType); + return false; + } + + napi_create_reference(env, arg, 1, returnCb); + return true; +} + +static uint32_t GetCertErrValueByErrCode(int32_t errCode) +{ + switch (errCode) { + case HCF_INVALID_PARAMS: + return JS_ERR_CERT_INVALID_PARAMS; + case HCF_NOT_SUPPORT: + return JS_ERR_CERT_NOT_SUPPORT; + case HCF_ERR_MALLOC: + return JS_ERR_CERT_OUT_OF_MEMORY; + case HCF_ERR_COPY: + return JS_ERR_CERT_RUNTIME_ERROR; + case HCF_ERR_CRYPTO_OPERATION: + return JS_ERR_CERT_CRYPTO_OPERATION; + case HCF_ERR_CERT_SIGNATURE_FAILURE: + return JS_ERR_CERT_SIGNATURE_FAILURE; + case HCF_ERR_CERT_NOT_YET_VALID: + return JS_ERR_CERT_NOT_YET_VALID; + case HCF_ERR_CERT_HAS_EXPIRED: + return JS_ERR_CERT_HAS_EXPIRED; + case HCF_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: + return JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY; + case HCF_ERR_KEYUSAGE_NO_CERTSIGN: + return JS_ERR_KEYUSAGE_NO_CERTSIGN; + case HCF_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE: + return JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE; + default: + return JS_ERR_DEFAULT_ERR; + } +} + +napi_value CertGenerateBusinessError(napi_env env, int32_t errCode, const char *errMsg) +{ + napi_value businessError = nullptr; + + napi_value code = nullptr; + napi_create_uint32(env, GetCertErrValueByErrCode(errCode), &code); + + napi_value msg = nullptr; + napi_create_string_utf8(env, errMsg, NAPI_AUTO_LENGTH, &msg); + + napi_create_error(env, nullptr, msg, &businessError); + napi_set_named_property(env, businessError, CERT_TAG_ERR_CODE.c_str(), code); + + return businessError; +} + +bool CertCheckArgsCount(napi_env env, size_t argc, size_t expectedCount, bool isSync) +{ + if (isSync) { + if (argc != expectedCount) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "invalid params count")); + LOGE("invalid params count!"); + return false; + } + } else { + if ((argc != expectedCount) && (argc != (expectedCount - ARGS_SIZE_ONE))) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "invalid params count")); + LOGE("invalid params count!"); + return false; + } + } + return true; +} + +napi_value CertGetResourceName(napi_env env, const char *name) +{ + napi_value resourceName = nullptr; + napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &resourceName); + return resourceName; +} + +napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob) +{ + if (blob == nullptr || blob->data == nullptr || blob->len == 0) { + LOGE("Invalid blob!"); + return nullptr; + } + uint8_t *buffer = static_cast(HcfMalloc(blob->len, 0)); + if (buffer == nullptr) { + LOGE("malloc uint8 array buffer failed!"); + return nullptr; + } + + if (memcpy_s(buffer, blob->len, blob->data, blob->len) != EOK) { + LOGE("memcpy_s data to buffer failed!"); + HcfFree(buffer); + return nullptr; + } + + napi_value outBuffer = nullptr; + napi_status status = napi_create_external_arraybuffer( + env, buffer, blob->len, [](napi_env env, void *data, void *hint) { HcfFree(data); }, nullptr, &outBuffer); + if (status != napi_ok) { + LOGE("create uint8 array buffer failed!"); + HcfFree(buffer); + return nullptr; + } + buffer = nullptr; + + napi_value outData = nullptr; + napi_create_typedarray(env, napi_uint8_array, blob->len, outBuffer, 0, &outData); + napi_value dataBlob = nullptr; + napi_create_object(env, &dataBlob); + napi_set_named_property(env, dataBlob, CERT_TAG_DATA.c_str(), outData); + + return dataBlob; +} + +static HcfResult ConvertBlobToWords(const HcfBlob &blob, uint64_t *&words, uint32_t &wordsCount) +{ + uint32_t blockSize = sizeof(uint64_t); + uint32_t convertDataSize = ((blob.len + (blockSize - 1)) >> QUAD_WORD_ALIGN_UP) << QUAD_WORD_ALIGN_UP; + uint8_t *convertData = static_cast(HcfMalloc(convertDataSize, 0)); + if (convertData == nullptr) { + LOGE("malloc convert data failed"); + return HCF_ERR_MALLOC; + } + + /* convertData has been initialized 0, reverse blob data */ + for (uint32_t i = 0; i < blob.len; ++i) { + convertData[i] = blob.data[blob.len - 1 - i]; + } + + words = reinterpret_cast(convertData); + wordsCount = convertDataSize / blockSize; + return HCF_SUCCESS; +} + +napi_value ConvertBlobToBigIntWords(napi_env env, const HcfBlob &blob) +{ + if (blob.data == nullptr || blob.len == 0 || blob.len > MAX_SN_BYTE_CNT) { + LOGE("Invalid blob!"); + return nullptr; + } + + uint64_t *words = nullptr; + uint32_t wordsCount = 0; + HcfResult ret = ConvertBlobToWords(blob, words, wordsCount); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "convert data to words failed")); + LOGE("cert convert data to words failed"); + return nullptr; + } + + napi_value result = nullptr; + napi_create_bigint_words(env, 0, wordsCount, words, &result); + HcfFree(words); + return result; +} +} // namespace CertFramework +} // namespace OHOS diff --git a/frameworks/js/napi/certificate/src/napi_certificate_init.cpp b/frameworks/js/napi/certificate/src/napi_certificate_init.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2b8d2ee49784baabdf17ebd22791ff777a159a87 --- /dev/null +++ b/frameworks/js/napi/certificate/src/napi_certificate_init.cpp @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2022 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 "securec.h" +#include "log.h" + +#include "napi_x509_certificate.h" +#include "napi_cert_chain_validator.h" +#include "napi_pub_key.h" +#include "napi_cert_utils.h" +#include "napi_x509_crl_entry.h" +#include "napi_x509_crl.h" +#include "napi_cert_defines.h" + +namespace OHOS { +namespace CertFramework { +static napi_value CreateEncodingFormat(napi_env env) +{ + napi_value encodingFormat = nullptr; + napi_create_object(env, &encodingFormat); + + CertAddUint32Property(env, encodingFormat, "FORMAT_DER", HCF_FORMAT_DER); + CertAddUint32Property(env, encodingFormat, "FORMAT_PEM", HCF_FORMAT_PEM); + + return encodingFormat; +} + +static void DefineEncodingFormatProperties(napi_env env, napi_value exports) +{ + napi_property_descriptor desc[] = { + DECLARE_NAPI_PROPERTY("EncodingFormat", CreateEncodingFormat(env)), + }; + napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); +} + +static napi_value CreateCertResultCode(napi_env env) +{ + napi_value resultCode = nullptr; + napi_create_object(env, &resultCode); + + CertAddUint32Property(env, resultCode, "INVALID_PARAMS", JS_ERR_CERT_INVALID_PARAMS); + CertAddUint32Property(env, resultCode, "NOT_SUPPORT", JS_ERR_CERT_NOT_SUPPORT); + CertAddUint32Property(env, resultCode, "ERR_OUT_OF_MEMORY", JS_ERR_CERT_OUT_OF_MEMORY); + CertAddUint32Property(env, resultCode, "ERR_RUNTIME_ERROR", JS_ERR_CERT_RUNTIME_ERROR); + CertAddUint32Property(env, resultCode, "ERR_CRYPTO_OPERATION", JS_ERR_CERT_CRYPTO_OPERATION); + CertAddUint32Property(env, resultCode, "ERR_CERT_SIGNATURE_FAILURE", JS_ERR_CERT_SIGNATURE_FAILURE); + CertAddUint32Property(env, resultCode, "ERR_CERT_NOT_YET_VALID", JS_ERR_CERT_NOT_YET_VALID); + CertAddUint32Property(env, resultCode, "ERR_CERT_HAS_EXPIRED", JS_ERR_CERT_HAS_EXPIRED); + CertAddUint32Property(env, resultCode, "ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY", + JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY); + CertAddUint32Property(env, resultCode, "ERR_KEYUSAGE_NO_CERTSIGN", JS_ERR_KEYUSAGE_NO_CERTSIGN); + CertAddUint32Property(env, resultCode, "ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE", JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE); + + return resultCode; +} + +static void DefineResultCodeProperties(napi_env env, napi_value exports) +{ + napi_property_descriptor desc[] = { + DECLARE_NAPI_PROPERTY("CertResult", CreateCertResultCode(env)), + }; + napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); +} + +/*********************************************** + * Module export and register + ***********************************************/ +static napi_value CertModuleExport(napi_env env, napi_value exports) +{ + LOGI("module init start."); + DefineEncodingFormatProperties(env, exports); + DefineResultCodeProperties(env, exports); + + NapiKey::DefineHcfKeyJSClass(env); + NapiPubKey::DefinePubKeyJSClass(env); + NapiCertChainValidator::DefineCertChainValidatorJSClass(env, exports); + NapiX509Certificate::DefineX509CertJSClass(env, exports); + NapiX509CrlEntry::DefineX509CrlEntryJSClass(env); + NapiX509Crl::DefineX509CrlJSClass(env, exports); + LOGI("module init end."); + return exports; +} + +extern "C" __attribute__((constructor)) void RegisterCertModule(void) +{ + static napi_module cryptoFrameworkCertModule = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = CertModuleExport, + .nm_modname = "security.cert", + .nm_priv = nullptr, + .reserved = { nullptr }, + }; + napi_module_register(&cryptoFrameworkCertModule); +} +} // namespace CertFramework +} // namespace OHOS diff --git a/frameworks/js/napi/certificate/src/napi_key.cpp b/frameworks/js/napi/certificate/src/napi_key.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0567b3c647d4902fc00861d016d5825a27127246 --- /dev/null +++ b/frameworks/js/napi/certificate/src/napi_key.cpp @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2023 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 "napi_key.h" + +#include "securec.h" +#include "log.h" +#include "napi_cert_defines.h" +#include "napi_cert_utils.h" + +namespace OHOS { +namespace CertFramework { +thread_local napi_ref NapiKey::classRef_ = nullptr; + +NapiKey::NapiKey(HcfKey *hcfKey) +{ + this->hcfKey_ = hcfKey; +} + +NapiKey::~NapiKey() {} + +HcfKey *NapiKey::GetHcfKey() const +{ + return this->hcfKey_; +} + +napi_value NapiKey::JsGetAlgorithm(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + NapiKey *napiKey = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); + + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); + HcfKey *key = napiKey->GetHcfKey(); + + const char *algo = key->getAlgorithm(key); + napi_value instance = nullptr; + napi_create_string_utf8(env, algo, NAPI_AUTO_LENGTH, &instance); + return instance; +} + +napi_value NapiKey::JsGetFormat(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + NapiKey *napiKey = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); + + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); + HcfKey *key = napiKey->GetHcfKey(); + + const char *format = key->getFormat(key); + napi_value instance = nullptr; + napi_create_string_utf8(env, format, NAPI_AUTO_LENGTH, &instance); + return instance; +} + +napi_value NapiKey::JsGetEncoded(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + NapiKey *napiKey = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); + + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); + HcfKey *key = napiKey->GetHcfKey(); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + HcfResult res = key->getEncoded(key, &blob); + if (res != 0) { + napi_throw(env, CertGenerateBusinessError(env, res, "getEncoded failed.")); + LOGE("getEncoded failed!"); + return nullptr; + } + napi_value instance = ConvertBlobToNapiValue(env, &blob); + HcfBlobDataFree(&blob); + return instance; +} + +napi_value NapiKey::KeyConstructor(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + return thisVar; +} + +void NapiKey::DefineHcfKeyJSClass(napi_env env) +{ + napi_property_descriptor classDesc[] = { + DECLARE_NAPI_FUNCTION("getEncoded", NapiKey::JsGetEncoded), + {.utf8name = "format", .getter = NapiKey::JsGetFormat}, + {.utf8name = "algName", .getter = NapiKey::JsGetAlgorithm}, + }; + napi_value constructor = nullptr; + napi_define_class(env, "HcfKey", NAPI_AUTO_LENGTH, KeyConstructor, nullptr, + sizeof(classDesc) / sizeof(classDesc[0]), classDesc, &constructor); + napi_create_reference(env, constructor, 1, &classRef_); +} +} // CertFramework +} // OHOS \ No newline at end of file diff --git a/frameworks/js/napi/certificate/src/napi_pub_key.cpp b/frameworks/js/napi/certificate/src/napi_pub_key.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5a05e1b2f2d7c2206b28771ef1e77c046a82f49b --- /dev/null +++ b/frameworks/js/napi/certificate/src/napi_pub_key.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2023 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 "napi_pub_key.h" + +#include "log.h" +#include "napi_cert_defines.h" +#include "napi_cert_utils.h" +#include "securec.h" + +namespace OHOS { +namespace CertFramework { +thread_local napi_ref NapiPubKey::classRef_ = nullptr; + +NapiPubKey::NapiPubKey(HcfPubKey *pubKey) : NapiKey(reinterpret_cast(pubKey)) {} + +NapiPubKey::~NapiPubKey() {} + +HcfPubKey *NapiPubKey::GetPubKey() +{ + return reinterpret_cast(NapiKey::GetHcfKey()); +} + +napi_value NapiPubKey::PubKeyConstructor(napi_env env, napi_callback_info info) +{ + LOGI("enter ..."); + + napi_value thisVar = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + + LOGI("out ..."); + return thisVar; +} + +napi_value NapiPubKey::ConvertToJsPubKey(napi_env env) +{ + LOGI("enter ..."); + + napi_value instance; + napi_value constructor = nullptr; + napi_get_reference_value(env, classRef_, &constructor); + napi_new_instance(env, constructor, 0, nullptr, &instance); + + const char *algName = this->GetPubKey()->base.getAlgorithm(&(this->GetPubKey()->base)); + const char *format = this->GetPubKey()->base.getFormat(&(this->GetPubKey()->base)); + + napi_value napiAlgName = nullptr; + napi_create_string_utf8(env, algName, NAPI_AUTO_LENGTH, &napiAlgName); + napi_set_named_property(env, instance, CRYPTO_TAG_ALG_NAME.c_str(), napiAlgName); + + napi_value napiFormat = nullptr; + napi_create_string_utf8(env, format, NAPI_AUTO_LENGTH, &napiFormat); + napi_set_named_property(env, instance, CRYPTO_TAG_FORMAT.c_str(), napiFormat); + + LOGI("out ..."); + return instance; +} + +napi_value NapiPubKey::JsGetEncoded(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + NapiPubKey *napiPubKey = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&napiPubKey)); + + HcfPubKey *pubKey = napiPubKey->GetPubKey(); + HcfBlob returnBlob; + HcfResult res = pubKey->base.getEncoded(&pubKey->base, &returnBlob); + if (res != HCF_SUCCESS) { + LOGE("c getEncoded fail."); + return nullptr; + } + + napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); + HcfBlobDataFree(&returnBlob); + return instance; +} + +void NapiPubKey::DefinePubKeyJSClass(napi_env env) +{ + napi_property_descriptor classDesc[] = { + DECLARE_NAPI_FUNCTION("getEncoded", NapiPubKey::JsGetEncoded), + }; + napi_value constructor = nullptr; + napi_define_class(env, "PubKey", NAPI_AUTO_LENGTH, NapiPubKey::PubKeyConstructor, nullptr, + sizeof(classDesc) / sizeof(classDesc[0]), classDesc, &constructor); + napi_create_reference(env, constructor, 1, &classRef_); +} +} // CertFramework +} // OHOS diff --git a/frameworks/js/napi/src/napi_x509_certificate.cpp b/frameworks/js/napi/certificate/src/napi_x509_certificate.cpp similarity index 71% rename from frameworks/js/napi/src/napi_x509_certificate.cpp rename to frameworks/js/napi/certificate/src/napi_x509_certificate.cpp index 5e834132ef202a4d188bfec0328c2ec0356a40a7..738fc5492140fe4f446093472dddafabe8b6fb0e 100644 --- a/frameworks/js/napi/src/napi_x509_certificate.cpp +++ b/frameworks/js/napi/certificate/src/napi_x509_certificate.cpp @@ -22,16 +22,16 @@ #include "utils.h" #include "object_base.h" #include "result.h" -#include "napi_crypto_framework_defines.h" +#include "napi_cert_defines.h" #include "napi_pub_key.h" -#include "napi_utils.h" +#include "napi_cert_utils.h" namespace OHOS { -namespace CryptoFramework { -napi_ref NapiX509Certificate::classRef_ = nullptr; +namespace CertFramework { +thread_local napi_ref NapiX509Certificate::classRef_ = nullptr; struct CfCtx { - CfAsyncType asyncType = ASYNC_TYPE_CALLBACK; + CertAsyncType asyncType = CERT_ASYNC_TYPE_CALLBACK; napi_value promise = nullptr; napi_ref callback = nullptr; napi_deferred deferred = nullptr; @@ -40,13 +40,11 @@ struct CfCtx { HcfEncodingBlob *encodingBlob = nullptr; NapiX509Certificate *certClass = nullptr; HcfPubKey *pubKey = nullptr; - std::string date; int32_t errCode = 0; const char *errMsg = nullptr; HcfX509Certificate *cert; HcfEncodingBlob *encoded = nullptr; - HcfPubKey *returnPubKey = nullptr; }; NapiX509Certificate::NapiX509Certificate(HcfX509Certificate *x509Cert) @@ -56,7 +54,7 @@ NapiX509Certificate::NapiX509Certificate(HcfX509Certificate *x509Cert) NapiX509Certificate::~NapiX509Certificate() { - OH_HCF_OBJ_DESTROY(this->x509Cert_); + HcfObjDestroy(this->x509Cert_); } static void FreeCryptoFwkCtx(napi_env env, CfCtx *context) @@ -88,7 +86,7 @@ static void ReturnCallbackResult(napi_env env, CfCtx *context, napi_value result { napi_value businessError = nullptr; if (context->errCode != HCF_SUCCESS) { - businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + businessError = CertGenerateBusinessError(env, context->errCode, context->errMsg); } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; @@ -106,13 +104,14 @@ static void ReturnPromiseResult(napi_env env, CfCtx *context, napi_value result) if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + CertGenerateBusinessError(env, context->errCode, context->errMsg)); } } static void ReturnResult(napi_env env, CfCtx *context, napi_value result) { - if (context->asyncType == ASYNC_TYPE_CALLBACK) { + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { ReturnCallbackResult(env, context, result); } else { ReturnPromiseResult(env, context, result); @@ -122,9 +121,9 @@ static void ReturnResult(napi_env env, CfCtx *context, napi_value result) static bool CreateCallbackAndPromise(napi_env env, CfCtx *context, size_t argc, size_t maxCount, napi_value callbackValue) { - context->asyncType = (argc == maxCount) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE; - if (context->asyncType == ASYNC_TYPE_CALLBACK) { - if (!GetCallbackFromJSParams(env, callbackValue, &context->callback)) { + context->asyncType = (argc == maxCount) ? CERT_ASYNC_TYPE_CALLBACK : CERT_ASYNC_TYPE_PROMISE; + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { + if (!CertGetCallbackFromJSParams(env, callbackValue, &context->callback)) { LOGE("get callback failed!"); return false; } @@ -139,7 +138,7 @@ static void VerifyExecute(napi_env env, void *data) LOGI("start to verify."); CfCtx *context = static_cast(data); HcfX509Certificate *cert = context->certClass->GetX509Cert(); - context->errCode = cert->base.verify((HcfCertificate *)cert, context->pubKey); + context->errCode = cert->base.verify(&(cert->base), context->pubKey); if (context->errCode != HCF_SUCCESS) { LOGE("verify cert failed!"); context->errMsg = "verify cert failed"; @@ -149,26 +148,7 @@ static void VerifyExecute(napi_env env, void *data) static void VerifyComplete(napi_env env, napi_status status, void *data) { CfCtx *context = static_cast(data); - ReturnResult(env, context, NapiGetNull(env)); - FreeCryptoFwkCtx(env, context); -} - -static void checkValidityWithDateExecute(napi_env env, void *data) -{ - LOGI("start to check validity."); - CfCtx *context = static_cast(data); - HcfX509Certificate *cert = context->certClass->GetX509Cert(); - context->errCode = cert->checkValidityWithDate(cert, context->date.c_str()); - if (context->errCode != HCF_SUCCESS) { - LOGE("check cert validity failed!"); - context->errMsg = "check cert validity failed"; - } -} - -static void checkValidityWithDateComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - ReturnResult(env, context, NapiGetNull(env)); + ReturnResult(env, context, CertNapiGetNull(env)); FreeCryptoFwkCtx(env, context); } @@ -176,14 +156,14 @@ static void GetEncodedExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); HcfX509Certificate *cert = context->certClass->GetX509Cert(); - HcfEncodingBlob *encodingBlob = (HcfEncodingBlob *)HcfMalloc(sizeof(HcfEncodingBlob), 0); + HcfEncodingBlob *encodingBlob = static_cast(HcfMalloc(sizeof(HcfEncodingBlob), 0)); if (encodingBlob == nullptr) { LOGE("malloc encoding blob failed!"); context->errCode = HCF_ERR_MALLOC; context->errMsg = "malloc encoding blob failed"; return; } - context->errCode = cert->base.getEncoded((HcfCertificate *)cert, encodingBlob); + context->errCode = cert->base.getEncoded(&(cert->base), encodingBlob); if (context->errCode != HCF_SUCCESS) { LOGE("get cert encoded failed!"); context->errMsg = "get cert encoded failed"; @@ -204,46 +184,13 @@ static void GetEncodedComplete(napi_env env, napi_status status, void *data) FreeCryptoFwkCtx(env, context); } -void GetPublicKeyExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509Certificate *cert = context->certClass->GetX509Cert(); - context->errCode = cert->base.getPublicKey((HcfCertificate *)cert, &context->returnPubKey); - if (context->errCode != HCF_SUCCESS) { - LOGE("get cert public key failed!"); - context->errMsg = "get cert public key failed"; - } -} - -void GetPublicKeyComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - NapiPubKey *pubKeyClass = new NapiPubKey(context->returnPubKey); - napi_value instance = pubKeyClass->ConvertToJsPubKey(env); - napi_wrap( - env, instance, pubKeyClass, - [](napi_env env, void *data, void *hint) { - NapiPubKey *pubKeyClass = (NapiPubKey *)data; - delete pubKeyClass; - return; - }, - nullptr, nullptr); - ReturnResult(env, context, instance); - FreeCryptoFwkCtx(env, context); -} - napi_value NapiX509Certificate::Verify(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } @@ -257,7 +204,7 @@ napi_value NapiX509Certificate::Verify(napi_env env, napi_callback_info info) NapiPubKey *pubKey = nullptr; napi_unwrap(env, argv[PARAM0], (void**)&pubKey); if (pubKey == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "public key is null")); + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "public key is null")); LOGE("pubKey is null!"); FreeCryptoFwkCtx(env, context); return nullptr; @@ -270,27 +217,27 @@ napi_value NapiX509Certificate::Verify(napi_env env, napi_callback_info info) } napi_create_async_work( - env, nullptr, GetResourceName(env, "Verify"), + env, nullptr, CertGetResourceName(env, "Verify"), VerifyExecute, VerifyComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509Certificate::GetEncoded(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } @@ -307,108 +254,75 @@ napi_value NapiX509Certificate::GetEncoded(napi_env env, napi_callback_info info } napi_create_async_work( - env, nullptr, GetResourceName(env, "GetEncoded"), + env, nullptr, CertGetResourceName(env, "GetEncoded"), GetEncodedExecute, GetEncodedComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509Certificate::GetPublicKey(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { - return nullptr; - } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + HcfX509Certificate *cert = GetX509Cert(); + HcfPubKey *returnPubKey = nullptr; + HcfResult ret = cert->base.getPublicKey(&(cert->base), &returnPubKey); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "get cert public key failed!")); + LOGE("get cert public key failed!"); return nullptr; } - context->certClass = this; - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_ONE, argv[PARAM0])) { - FreeCryptoFwkCtx(env, context); + NapiPubKey *pubKeyClass = new (std::nothrow) NapiPubKey(returnPubKey); + if (pubKeyClass == nullptr) { + LOGE("create for x509 cert's public key obj failed"); + HcfObjDestroy(returnPubKey); return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetPublicKey"), - GetPublicKeyExecute, - GetPublicKeyComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value instance = pubKeyClass->ConvertToJsPubKey(env); + napi_wrap( + env, instance, pubKeyClass, + [](napi_env env, void *data, void *hint) { + NapiPubKey *pubKeyClass = static_cast(data); + HcfObjDestroy(pubKeyClass->GetPubKey()); + delete pubKeyClass; + return; + }, + nullptr, nullptr); + return instance; } napi_value NapiX509Certificate::CheckValidityWithDate(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, true)) { return nullptr; } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); - return nullptr; - } - context->certClass = this; - - if (!GetStringFromJSParams(env, argv[PARAM0], context->date)) { + std::string date; + if (!CertGetStringFromJSParams(env, argv[PARAM0], date)) { LOGE("get date param failed!"); - FreeCryptoFwkCtx(env, context); - return nullptr; - } - - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_TWO, argv[PARAM1])) { - FreeCryptoFwkCtx(env, context); return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "CheckValidityWithDate"), - checkValidityWithDateExecute, - checkValidityWithDateComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); + HcfX509Certificate *cert = GetX509Cert(); + HcfResult ret = cert->checkValidityWithDate(cert, date.c_str()); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "check cert validity failed!")); + LOGE("check cert validity failed!"); } + return nullptr; } napi_value NapiX509Certificate::GetVersion(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } HcfX509Certificate *cert = GetX509Cert(); int version = cert->getVersion(cert); napi_value result = nullptr; @@ -416,32 +330,25 @@ napi_value NapiX509Certificate::GetVersion(napi_env env, napi_callback_info info return result; } - napi_value NapiX509Certificate::GetSerialNumber(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { + HcfX509Certificate *cert = GetX509Cert(); + HcfBlob blob = { nullptr, 0 }; + HcfResult ret = cert->getSerialNumber(cert, &blob); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "cert get serial num failed")); + LOGE("get serial num failed!"); return nullptr; } - HcfX509Certificate *cert = GetX509Cert(); - long serialNumber = cert->getSerialNumber(cert); - napi_value result = nullptr; - napi_create_int64(env, serialNumber, &result); + + napi_value result = ConvertBlobToBigIntWords(env, blob); + HcfBlobDataFree(&blob); return result; } napi_value NapiX509Certificate::GetIssuerName(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -449,13 +356,13 @@ napi_value NapiX509Certificate::GetIssuerName(napi_env env, napi_callback_info i HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getIssuerName(cert, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get issuer name failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get issuer name failed")); LOGE("getIssuerName failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnValue = ConvertBlobToNapiValue(env, blob); + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -464,14 +371,7 @@ napi_value NapiX509Certificate::GetIssuerName(napi_env env, napi_callback_info i napi_value NapiX509Certificate::GetSubjectName(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -479,13 +379,13 @@ napi_value NapiX509Certificate::GetSubjectName(napi_env env, napi_callback_info HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getSubjectName(cert, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get subject name failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get subject name failed")); LOGE("getSubjectName failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnValue = ConvertBlobToNapiValue(env, blob); + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -494,14 +394,7 @@ napi_value NapiX509Certificate::GetSubjectName(napi_env env, napi_callback_info napi_value NapiX509Certificate::GetNotBeforeTime(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -509,14 +402,14 @@ napi_value NapiX509Certificate::GetNotBeforeTime(napi_env env, napi_callback_inf HcfX509Certificate *cert = GetX509Cert(); HcfResult res = cert->getNotBeforeTime(cert, blob); if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "get not before time failed")); + napi_throw(env, CertGenerateBusinessError(env, res, "get not before time failed")); LOGE("getNotBeforeTime failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -525,14 +418,7 @@ napi_value NapiX509Certificate::GetNotBeforeTime(napi_env env, napi_callback_inf napi_value NapiX509Certificate::GetNotAfterTime(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -540,14 +426,14 @@ napi_value NapiX509Certificate::GetNotAfterTime(napi_env env, napi_callback_info HcfX509Certificate *cert = GetX509Cert(); HcfResult res = cert->getNotAfterTime(cert, blob); if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "get not after time failed")); + napi_throw(env, CertGenerateBusinessError(env, res, "get not after time failed")); LOGE("getNotAfterTime failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -556,14 +442,7 @@ napi_value NapiX509Certificate::GetNotAfterTime(napi_env env, napi_callback_info napi_value NapiX509Certificate::GetSignature(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -571,13 +450,13 @@ napi_value NapiX509Certificate::GetSignature(napi_env env, napi_callback_info in HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getSignature(cert, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get signature failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get signature failed")); LOGE("getSignature failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnValue = ConvertBlobToNapiValue(env, blob); + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -586,14 +465,7 @@ napi_value NapiX509Certificate::GetSignature(napi_env env, napi_callback_info in napi_value NapiX509Certificate::GetSigAlgName(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -601,14 +473,14 @@ napi_value NapiX509Certificate::GetSigAlgName(napi_env env, napi_callback_info i HcfX509Certificate *cert = GetX509Cert(); HcfResult res = cert->getSignatureAlgName(cert, blob); if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "get signature alg name failed")); + napi_throw(env, CertGenerateBusinessError(env, res, "get signature alg name failed")); LOGE("getSignatureAlgName failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -617,13 +489,7 @@ napi_value NapiX509Certificate::GetSigAlgName(napi_env env, napi_callback_info i napi_value NapiX509Certificate::GetSigAlgOID(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -631,14 +497,14 @@ napi_value NapiX509Certificate::GetSigAlgOID(napi_env env, napi_callback_info in HcfX509Certificate *cert = GetX509Cert(); HcfResult res = cert->getSignatureAlgOid(cert, blob); if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "get signature alg oid failed")); + napi_throw(env, CertGenerateBusinessError(env, res, "get signature alg oid failed")); LOGE("getSignatureAlgOid failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -647,14 +513,7 @@ napi_value NapiX509Certificate::GetSigAlgOID(napi_env env, napi_callback_info in napi_value NapiX509Certificate::GetSigAlgParams(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -662,13 +521,13 @@ napi_value NapiX509Certificate::GetSigAlgParams(napi_env env, napi_callback_info HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getSignatureAlgParams(cert, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get signature alg params failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get signature alg params failed")); LOGE("getSignatureAlgParams failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnValue = ConvertBlobToNapiValue(env, blob); + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -677,13 +536,7 @@ napi_value NapiX509Certificate::GetSigAlgParams(napi_env env, napi_callback_info napi_value NapiX509Certificate::GetKeyUsage(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; @@ -691,13 +544,13 @@ napi_value NapiX509Certificate::GetKeyUsage(napi_env env, napi_callback_info inf HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getKeyUsage(cert, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get key usage failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get key usage failed")); LOGE("getKeyUsage failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnValue = ConvertBlobToNapiValue(env, blob); + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -706,13 +559,7 @@ napi_value NapiX509Certificate::GetKeyUsage(napi_env env, napi_callback_info inf napi_value NapiX509Certificate::GetExtendedKeyUsage(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfArray *array = (HcfArray *)HcfMalloc(sizeof(HcfArray), 0); + HcfArray *array = reinterpret_cast(HcfMalloc(sizeof(HcfArray), 0)); if (array == nullptr) { LOGE("malloc array failed!"); return nullptr; @@ -720,7 +567,7 @@ napi_value NapiX509Certificate::GetExtendedKeyUsage(napi_env env, napi_callback_ HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getExtKeyUsage(cert, array); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get ext key usage failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get ext key usage failed")); LOGE("call getExtKeyUsage failed!"); HcfFree(array); array = nullptr; @@ -736,13 +583,6 @@ napi_value NapiX509Certificate::GetExtendedKeyUsage(napi_env env, napi_callback_ napi_value NapiX509Certificate::GetBasicConstraints(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Certificate *cert = GetX509Cert(); int32_t constrains = cert->getBasicConstraints(cert); napi_value result = nullptr; @@ -752,13 +592,7 @@ napi_value NapiX509Certificate::GetBasicConstraints(napi_env env, napi_callback_ napi_value NapiX509Certificate::GetSubjectAlternativeNames(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfArray *array = (HcfArray *)HcfMalloc(sizeof(HcfArray), 0); + HcfArray *array = reinterpret_cast(HcfMalloc(sizeof(HcfArray), 0)); if (array == nullptr) { LOGE("malloc array failed!"); return nullptr; @@ -766,7 +600,7 @@ napi_value NapiX509Certificate::GetSubjectAlternativeNames(napi_env env, napi_ca HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getSubjectAltNames(cert, array); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get subject alt names failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get subject alt names failed")); LOGE("call getSubjectAltNames failed!"); HcfFree(array); array = nullptr; @@ -781,13 +615,7 @@ napi_value NapiX509Certificate::GetSubjectAlternativeNames(napi_env env, napi_ca napi_value NapiX509Certificate::GetIssuerAlternativeNames(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - - HcfArray *array = (HcfArray *)HcfMalloc(sizeof(HcfArray), 0); + HcfArray *array = reinterpret_cast(HcfMalloc(sizeof(HcfArray), 0)); if (array == nullptr) { LOGE("malloc array failed!"); return nullptr; @@ -795,7 +623,7 @@ napi_value NapiX509Certificate::GetIssuerAlternativeNames(napi_env env, napi_cal HcfX509Certificate *cert = GetX509Cert(); HcfResult ret = cert->getIssuerAltNames(cert, array); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get issuer alt names failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get issuer alt names failed")); LOGE("call getIssuerAltNames failed!"); HcfFree(array); array = nullptr; @@ -1059,6 +887,9 @@ void NapiX509Certificate::CreateX509CertExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); context->errCode = HcfX509CertificateCreate(context->encodingBlob, &context->cert); + if (context->errCode != HCF_SUCCESS) { + context->errMsg = "create X509Cert failed"; + } } void NapiX509Certificate::CreateX509CertComplete(napi_env env, napi_status status, void *data) @@ -1075,7 +906,7 @@ void NapiX509Certificate::CreateX509CertComplete(napi_env env, napi_status statu napi_wrap( env, instance, x509CertClass, [](napi_env env, void *data, void *hint) { - NapiX509Certificate *certClass = (NapiX509Certificate *)data; + NapiX509Certificate *certClass = static_cast(data); delete certClass; return; }, @@ -1087,10 +918,10 @@ void NapiX509Certificate::CreateX509CertComplete(napi_env env, napi_status statu napi_value NapiX509Certificate::NapiCreateX509Cert(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } @@ -1111,17 +942,17 @@ napi_value NapiX509Certificate::NapiCreateX509Cert(napi_env env, napi_callback_i } napi_create_async_work( - env, nullptr, GetResourceName(env, "CreateX509Cert"), + env, nullptr, CertGetResourceName(env, "CreateX509Cert"), CreateX509CertExecute, CreateX509CertComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } @@ -1174,5 +1005,5 @@ napi_value NapiX509Certificate::CreateX509Cert(napi_env env) napi_new_instance(env, constructor, 0, nullptr, &instance); return instance; } -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS diff --git a/frameworks/js/napi/src/napi_x509_crl.cpp b/frameworks/js/napi/certificate/src/napi_x509_crl.cpp similarity index 67% rename from frameworks/js/napi/src/napi_x509_crl.cpp rename to frameworks/js/napi/certificate/src/napi_x509_crl.cpp index ec4ac3aa362ea23699d67750183494030f1d6963..b1c59b7f2cb0f080ad524d3b6c24fb6321cc82e2 100644 --- a/frameworks/js/napi/src/napi_x509_crl.cpp +++ b/frameworks/js/napi/certificate/src/napi_x509_crl.cpp @@ -22,18 +22,18 @@ #include "utils.h" #include "object_base.h" #include "result.h" -#include "napi_crypto_framework_defines.h" +#include "napi_cert_defines.h" #include "napi_pub_key.h" -#include "napi_utils.h" +#include "napi_cert_utils.h" #include "napi_x509_certificate.h" #include "napi_x509_crl_entry.h" namespace OHOS { -namespace CryptoFramework { -napi_ref NapiX509Crl::classRef_ = nullptr; +namespace CertFramework { +thread_local napi_ref NapiX509Crl::classRef_ = nullptr; struct CfCtx { - CfAsyncType asyncType = ASYNC_TYPE_CALLBACK; + CertAsyncType asyncType = CERT_ASYNC_TYPE_CALLBACK; napi_value promise = nullptr; napi_ref callback = nullptr; napi_deferred deferred = nullptr; @@ -48,7 +48,6 @@ struct CfCtx { HcfX509CrlEntry *crlEntry = nullptr; int32_t errCode = 0; const char *errMsg = nullptr; - bool isRevoked = false; HcfX509Crl *crl; HcfEncodingBlob *encoded = nullptr; HcfBlob *blob = nullptr; @@ -95,7 +94,7 @@ static void ReturnCallbackResult(napi_env env, CfCtx *context, napi_value result { napi_value businessError = nullptr; if (context->errCode != HCF_SUCCESS) { - businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + businessError = CertGenerateBusinessError(env, context->errCode, context->errMsg); } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; @@ -113,13 +112,14 @@ static void ReturnPromiseResult(napi_env env, CfCtx *context, napi_value result) if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + CertGenerateBusinessError(env, context->errCode, context->errMsg)); } } static void ReturnResult(napi_env env, CfCtx *context, napi_value result) { - if (context->asyncType == ASYNC_TYPE_CALLBACK) { + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { ReturnCallbackResult(env, context, result); } else { ReturnPromiseResult(env, context, result); @@ -129,9 +129,9 @@ static void ReturnResult(napi_env env, CfCtx *context, napi_value result) static bool CreateCallbackAndPromise(napi_env env, CfCtx *context, size_t argc, size_t maxCount, napi_value callbackValue) { - context->asyncType = (argc == maxCount) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE; - if (context->asyncType == ASYNC_TYPE_CALLBACK) { - if (!GetCallbackFromJSParams(env, callbackValue, &context->callback)) { + context->asyncType = (argc == maxCount) ? CERT_ASYNC_TYPE_CALLBACK : CERT_ASYNC_TYPE_PROMISE; + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { + if (!CertGetCallbackFromJSParams(env, callbackValue, &context->callback)) { LOGE("get callback failed!"); return false; } @@ -148,35 +148,14 @@ NapiX509Crl::NapiX509Crl(HcfX509Crl *x509Crl) NapiX509Crl::~NapiX509Crl() { - OH_HCF_OBJ_DESTROY(this->x509Crl_); -} - -void IsInvokedExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - context->isRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)context->certificate); - context->errCode = HCF_SUCCESS; -} - -void IsInvokedComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - napi_value result = nullptr; - if (context->isRevoked) { - napi_get_boolean(env, true, &result); - } else { - napi_get_boolean(env, false, &result); - } - ReturnResult(env, context, result); - FreeCryptoFwkCtx(env, context); + HcfObjDestroy(this->x509Crl_); } static void GetEncodedExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - HcfEncodingBlob *encodingBlob = (HcfEncodingBlob *)HcfMalloc(sizeof(HcfEncodingBlob), 0); + HcfEncodingBlob *encodingBlob = static_cast(HcfMalloc(sizeof(HcfEncodingBlob), 0)); if (encodingBlob == nullptr) { LOGE("malloc encoding blob failed!"); context->errCode = HCF_ERR_MALLOC; @@ -218,73 +197,7 @@ static void VerifyExecute(napi_env env, void *data) static void VerifyComplete(napi_env env, napi_status status, void *data) { CfCtx *context = static_cast(data); - ReturnResult(env, context, NapiGetNull(env)); - FreeCryptoFwkCtx(env, context); -} - -void GetRevokedCertificateExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - context->errCode = x509Crl->getRevokedCert(x509Crl, context->serialNumber, &context->crlEntry); - if (context->errCode != HCF_SUCCESS) { - LOGE("get revoked cert failed!"); - context->errMsg = "get revoked cert failed"; - } -} - -void GetRevokedCertificateComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - napi_value instance = NapiX509CrlEntry::CreateX509CrlEntry(env); - NapiX509CrlEntry *x509CrlEntryClass = new NapiX509CrlEntry(context->crlEntry); - napi_wrap( - env, instance, x509CrlEntryClass, - [](napi_env env, void *data, void *hint) { - NapiX509CrlEntry *x509CrlEntryClass = (NapiX509CrlEntry *)data; - delete x509CrlEntryClass; - return; - }, - nullptr, nullptr); - ReturnResult(env, context, instance); - FreeCryptoFwkCtx(env, context); -} - -void GetRevokedCertificateWithCertExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - context->errCode = x509Crl->getRevokedCertWithCert(x509Crl, context->certificate, &context->crlEntry); - if (context->errCode != HCF_SUCCESS) { - LOGE("get revoked cert with cert failed!"); - context->errMsg = "get revoked cert with cert failed"; - } -} - -void GetRevokedCertificateWithCertComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - napi_value instance = NapiX509CrlEntry::CreateX509CrlEntry(env); - NapiX509CrlEntry *x509CrlEntryClass = new NapiX509CrlEntry(context->crlEntry); - napi_wrap( - env, instance, x509CrlEntryClass, - [](napi_env env, void *data, void *hint) { - NapiX509CrlEntry *x509CrlEntryClass = (NapiX509CrlEntry *)data; - delete x509CrlEntryClass; - return; - }, - nullptr, nullptr); - ReturnResult(env, context, instance); + ReturnResult(env, context, CertNapiGetNull(env)); FreeCryptoFwkCtx(env, context); } @@ -292,7 +205,7 @@ void GetRevokedCertificatesExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - HcfArray *array = (HcfArray *)HcfMalloc(sizeof(HcfArray), 0); + HcfArray *array = reinterpret_cast(HcfMalloc(sizeof(HcfArray), 0)); if (array == nullptr) { LOGE("malloc array failed!"); context->errCode = HCF_ERR_MALLOC; @@ -320,14 +233,14 @@ static napi_value GenerateCrlEntryArray(napi_env env, HcfArray *array) napi_value returnArray = nullptr; napi_create_array(env, &returnArray); for (uint32_t i = 0; i < array->count; i++) { - HcfBlob *blob = (HcfBlob *)(array->data + i); - HcfX509CrlEntry *entry = (HcfX509CrlEntry *)blob->data; + HcfBlob *blob = reinterpret_cast(array->data + i); + HcfX509CrlEntry *entry = reinterpret_cast(blob->data); napi_value instance = NapiX509CrlEntry::CreateX509CrlEntry(env); NapiX509CrlEntry *x509CrlEntryClass = new NapiX509CrlEntry(entry); napi_wrap( env, instance, x509CrlEntryClass, [](napi_env env, void *data, void *hint) { - NapiX509CrlEntry *x509CrlEntryClass = (NapiX509CrlEntry *)data; + NapiX509CrlEntry *x509CrlEntryClass = static_cast(data); delete x509CrlEntryClass; return; }, @@ -350,93 +263,36 @@ void GetRevokedCertificatesComplete(napi_env env, napi_status status, void *data FreeCryptoFwkCtx(env, context); } -void GetTBSCertListExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509Crl *x509Crl = context->crlClass->GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); - if (blob == nullptr) { - LOGE("malloc blob failed!"); - context->errCode = HCF_ERR_MALLOC; - context->errMsg = "malloc blob failed"; - return; - } - context->errCode = x509Crl->getTbsInfo(x509Crl, blob); - if (context->errCode != HCF_SUCCESS) { - LOGE("get tbs info failed!"); - context->errMsg = "get tbs info failed"; - } - context->blob = blob; -} - -void GetTBSCertListComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - napi_value returnBlob = ConvertBlobToNapiValue(env, context->blob); - ReturnResult(env, context, returnBlob); - FreeCryptoFwkCtx(env, context); -} - napi_value NapiX509Crl::IsRevoked(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, true)) { return nullptr; } - NapiX509Certificate *x509Cert = nullptr; - napi_unwrap(env, argv[PARAM0], (void**)&x509Cert); - if (x509Cert == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "x509 cert is null")); - LOGE("x509Cert is null!"); - return nullptr; - } - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + NapiX509Certificate *napiX509Cert = nullptr; + napi_unwrap(env, argv[PARAM0], reinterpret_cast(&napiX509Cert)); + if (napiX509Cert == nullptr) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "napiX509Cert is null")); + LOGE("napiX509Cert is null!"); return nullptr; } - context->certificate = x509Cert->GetX509Cert(); - context->crlClass = this; - - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_TWO, argv[PARAM1])) { - FreeCryptoFwkCtx(env, context); - return nullptr; - } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "IsRevoked"), - IsInvokedExecute, - IsInvokedComplete, - (void *)context, - &context->asyncWork); - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + HcfX509Crl *x509Crl = GetX509Crl(); + HcfX509Certificate *certificate = napiX509Cert->GetX509Cert(); + bool isRevoked = x509Crl->base.isRevoked(&(x509Crl->base), &(certificate->base)); + napi_value result = nullptr; + napi_get_boolean(env, isRevoked, &result); + return result; } napi_value NapiX509Crl::GetType(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - const char *type = x509Crl->base.getType((HcfCrl *)x509Crl); + const char *type = x509Crl->base.getType(&(x509Crl->base)); napi_value result = nullptr; napi_create_string_utf8(env, type, strlen(type), &result); return result; @@ -445,10 +301,10 @@ napi_value NapiX509Crl::GetType(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetEncoded(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } @@ -465,34 +321,34 @@ napi_value NapiX509Crl::GetEncoded(napi_env env, napi_callback_info info) } napi_create_async_work( - env, nullptr, GetResourceName(env, "GetEncoded"), + env, nullptr, CertGetResourceName(env, "GetEncoded"), GetEncodedExecute, GetEncodedComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509Crl::Verify(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } NapiPubKey *pubKey = nullptr; - napi_unwrap(env, argv[PARAM0], (void**)&pubKey); + napi_unwrap(env, argv[PARAM0], reinterpret_cast(&pubKey)); if (pubKey == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "public key is null")); + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "public key is null")); LOGE("pubKey is null!"); return nullptr; } @@ -511,28 +367,22 @@ napi_value NapiX509Crl::Verify(napi_env env, napi_callback_info info) } napi_create_async_work( - env, nullptr, GetResourceName(env, "Verify"), + env, nullptr, CertGetResourceName(env, "Verify"), VerifyExecute, VerifyComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509Crl::GetVersion(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); int version = x509Crl->getVersion(x509Crl); napi_value result = nullptr; @@ -542,27 +392,21 @@ napi_value NapiX509Crl::GetVersion(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetIssuerDN(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult ret = x509Crl->getIssuerName(x509Crl, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get issuer name failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get issuer name failed")); LOGE("getIssuerDN failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnBlob = ConvertBlobToNapiValue(env, blob); + napi_value returnBlob = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -571,28 +415,22 @@ napi_value NapiX509Crl::GetIssuerDN(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetThisUpdate(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult ret = x509Crl->getLastUpdate(x509Crl, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get last update failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get last update failed")); LOGE("getLastUpdate failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -601,28 +439,22 @@ napi_value NapiX509Crl::GetThisUpdate(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetNextUpdate(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult ret = x509Crl->getNextUpdate(x509Crl, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get next update failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get next update failed")); LOGE("getNextUpdate failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -631,100 +463,87 @@ napi_value NapiX509Crl::GetNextUpdate(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetRevokedCertificate(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { - return nullptr; - } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, true)) { return nullptr; } - context->crlClass = this; - - if (!GetInt32FromJSParams(env, argv[PARAM0], context->serialNumber)) { + int32_t serialNumber = 0; + if (!CertGetInt32FromJSParams(env, argv[PARAM0], serialNumber)) { LOGE("get serialNumber failed!"); - FreeCryptoFwkCtx(env, context); return nullptr; } - - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_TWO, argv[PARAM1])) { - FreeCryptoFwkCtx(env, context); + HcfX509Crl *x509Crl = GetX509Crl(); + HcfX509CrlEntry *crlEntry = nullptr; + HcfResult ret = x509Crl->getRevokedCert(x509Crl, serialNumber, &crlEntry); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "get revoked cert failed!")); + LOGE("get revoked cert failed!"); return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetRevokedCertificate"), - GetRevokedCertificateExecute, - GetRevokedCertificateComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value instance = NapiX509CrlEntry::CreateX509CrlEntry(env); + NapiX509CrlEntry *x509CrlEntryClass = new NapiX509CrlEntry(crlEntry); + napi_wrap( + env, instance, x509CrlEntryClass, + [](napi_env env, void *data, void *hint) { + NapiX509CrlEntry *x509CrlEntryClass = static_cast(data); + delete x509CrlEntryClass; + return; + }, + nullptr, nullptr); + return instance; } napi_value NapiX509Crl::GetRevokedCertificateWithCert(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { - return nullptr; - } - - NapiX509Certificate *x509Cert = nullptr; - napi_unwrap(env, argv[PARAM0], (void**)&x509Cert); - if (x509Cert == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "x509 cert is null")); - LOGE("x509Cert is null!"); + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, true)) { return nullptr; } - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + NapiX509Certificate *napiX509Cert = nullptr; + napi_unwrap(env, argv[PARAM0], reinterpret_cast(&napiX509Cert)); + if (napiX509Cert == nullptr) { + napi_throw(env, CertGenerateBusinessError(env, HCF_INVALID_PARAMS, "napiX509Cert is null")); + LOGE("napiX509Cert is null!"); return nullptr; } - context->certificate = x509Cert->GetX509Cert(); - context->crlClass = this; - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_TWO, argv[PARAM1])) { - FreeCryptoFwkCtx(env, context); + HcfX509Certificate *certificate = napiX509Cert->GetX509Cert(); + HcfX509Crl *x509Crl = GetX509Crl(); + HcfX509CrlEntry *crlEntry = nullptr; + HcfResult ret = x509Crl->getRevokedCertWithCert(x509Crl, certificate, &crlEntry); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "get revoked cert with cert failed!")); + LOGE("get revoked cert with cert failed!"); return nullptr; } - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetRevokedCertificateWithCert"), - GetRevokedCertificateWithCertExecute, - GetRevokedCertificateWithCertComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value instance = NapiX509CrlEntry::CreateX509CrlEntry(env); + NapiX509CrlEntry *x509CrlEntryClass = new NapiX509CrlEntry(crlEntry); + napi_wrap( + env, instance, x509CrlEntryClass, + [](napi_env env, void *data, void *hint) { + NapiX509CrlEntry *x509CrlEntryClass = static_cast(data); + delete x509CrlEntryClass; + return; + }, + nullptr, nullptr); + return instance; } napi_value NapiX509Crl::GetRevokedCertificates(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } @@ -741,80 +560,60 @@ napi_value NapiX509Crl::GetRevokedCertificates(napi_env env, napi_callback_info } napi_create_async_work( - env, nullptr, GetResourceName(env, "GetRevokedCertificates"), + env, nullptr, CertGetResourceName(env, "GetRevokedCertificates"), GetRevokedCertificatesExecute, GetRevokedCertificatesComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509Crl::GetTBSCertList(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { - return nullptr; - } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + HcfX509Crl *x509Crl = GetX509Crl(); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); + if (blob == nullptr) { + LOGE("malloc blob failed!"); return nullptr; } - context->crlClass = this; - - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_ONE, argv[PARAM0])) { - FreeCryptoFwkCtx(env, context); + HcfResult result = x509Crl->getSignature(x509Crl, blob); + if (result != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, result, "get tbs info failed")); + LOGE("get tbs info failed!"); + HcfFree(blob); + blob = nullptr; return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetTBSCertList"), - GetTBSCertListExecute, - GetTBSCertListComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value returnBlob = CertConvertBlobToNapiValue(env, blob); + HcfBlobDataFree(blob); + HcfFree(blob); + blob = nullptr; + return returnBlob; } napi_value NapiX509Crl::GetSignature(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult result = x509Crl->getSignature(x509Crl, blob); if (result != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, result, "get signature failed")); + napi_throw(env, CertGenerateBusinessError(env, result, "get signature failed")); LOGE("getSignature failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnBlob = ConvertBlobToNapiValue(env, blob); + napi_value returnBlob = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -823,28 +622,22 @@ napi_value NapiX509Crl::GetSignature(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetSigAlgName(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult ret = x509Crl->getSignatureAlgName(x509Crl, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get signature alg name failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get signature alg name failed")); LOGE("getSigAlgName failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -853,28 +646,22 @@ napi_value NapiX509Crl::GetSigAlgName(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetSigAlgOID(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult ret = x509Crl->getSignatureAlgOid(x509Crl, blob); if (ret != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, ret, "get signature alg oid failed")); + napi_throw(env, CertGenerateBusinessError(env, ret, "get signature alg oid failed")); LOGE("getSigAlgOID failed!"); HcfFree(blob); blob = nullptr; return nullptr; } napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &result); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -883,27 +670,21 @@ napi_value NapiX509Crl::GetSigAlgOID(napi_env env, napi_callback_info info) napi_value NapiX509Crl::GetSigAlgParams(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } - HcfX509Crl *x509Crl = GetX509Crl(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (blob == nullptr) { LOGE("malloc blob failed!"); return nullptr; } HcfResult result = x509Crl->getSignatureAlgParams(x509Crl, blob); if (result != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, result, "get signature alg params failed")); + napi_throw(env, CertGenerateBusinessError(env, result, "get signature alg params failed")); LOGE("getSigAlgParams failed!"); HcfFree(blob); blob = nullptr; return nullptr; } - napi_value returnBlob = ConvertBlobToNapiValue(env, blob); + napi_value returnBlob = CertConvertBlobToNapiValue(env, blob); HcfBlobDataFree(blob); HcfFree(blob); blob = nullptr; @@ -1124,6 +905,9 @@ void NapiX509Crl::CreateX509CrlExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); context->errCode = HcfX509CrlCreate(context->encodingBlob, &context->crl); + if (context->errCode != HCF_SUCCESS) { + context->errMsg = "create X509Crl failed"; + } } void NapiX509Crl::CreateX509CrlComplete(napi_env env, napi_status status, void *data) @@ -1140,7 +924,7 @@ void NapiX509Crl::CreateX509CrlComplete(napi_env env, napi_status status, void * napi_wrap( env, instance, x509CrlClass, [](napi_env env, void *data, void *hint) { - NapiX509Crl *crlClass = (NapiX509Crl *)data; + NapiX509Crl *crlClass = static_cast(data); delete crlClass; return; }, @@ -1152,10 +936,10 @@ void NapiX509Crl::CreateX509CrlComplete(napi_env env, napi_status status, void * napi_value NapiX509Crl::NapiCreateX509Crl(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } @@ -1176,17 +960,17 @@ napi_value NapiX509Crl::NapiCreateX509Crl(napi_env env, napi_callback_info info) } napi_create_async_work( - env, nullptr, GetResourceName(env, "createX509Crl"), + env, nullptr, CertGetResourceName(env, "createX509Crl"), CreateX509CrlExecute, CreateX509CrlComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } @@ -1236,5 +1020,5 @@ napi_value NapiX509Crl::CreateX509Crl(napi_env env) napi_new_instance(env, constructor, 0, nullptr, &instance); return instance; } -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS diff --git a/frameworks/js/napi/src/napi_x509_crl_entry.cpp b/frameworks/js/napi/certificate/src/napi_x509_crl_entry.cpp similarity index 61% rename from frameworks/js/napi/src/napi_x509_crl_entry.cpp rename to frameworks/js/napi/certificate/src/napi_x509_crl_entry.cpp index cec64bd8676ed29c22ee1c110f4e31e50f102424..f43ef9cecfe958d4ae5ad53d3eb14a4db7f03568 100644 --- a/frameworks/js/napi/src/napi_x509_crl_entry.cpp +++ b/frameworks/js/napi/certificate/src/napi_x509_crl_entry.cpp @@ -22,15 +22,15 @@ #include "utils.h" #include "object_base.h" #include "result.h" -#include "napi_crypto_framework_defines.h" -#include "napi_utils.h" +#include "napi_cert_defines.h" +#include "napi_cert_utils.h" namespace OHOS { -namespace CryptoFramework { -napi_ref NapiX509CrlEntry::classRef_ = nullptr; +namespace CertFramework { +thread_local napi_ref NapiX509CrlEntry::classRef_ = nullptr; struct CfCtx { - CfAsyncType asyncType = ASYNC_TYPE_CALLBACK; + CertAsyncType asyncType = CERT_ASYNC_TYPE_CALLBACK; napi_value promise = nullptr; napi_ref callback = nullptr; napi_deferred deferred = nullptr; @@ -73,7 +73,7 @@ static void ReturnCallbackResult(napi_env env, CfCtx *context, napi_value result { napi_value businessError = nullptr; if (context->errCode != HCF_SUCCESS) { - businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + businessError = CertGenerateBusinessError(env, context->errCode, context->errMsg); } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; @@ -91,13 +91,14 @@ static void ReturnPromiseResult(napi_env env, CfCtx *context, napi_value result) if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + CertGenerateBusinessError(env, context->errCode, context->errMsg)); } } static void ReturnResult(napi_env env, CfCtx *context, napi_value result) { - if (context->asyncType == ASYNC_TYPE_CALLBACK) { + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { ReturnCallbackResult(env, context, result); } else { ReturnPromiseResult(env, context, result); @@ -107,9 +108,9 @@ static void ReturnResult(napi_env env, CfCtx *context, napi_value result) static bool CreateCallbackAndPromise(napi_env env, CfCtx *context, size_t argc, size_t maxCount, napi_value callbackValue) { - context->asyncType = (argc == maxCount) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE; - if (context->asyncType == ASYNC_TYPE_CALLBACK) { - if (!GetCallbackFromJSParams(env, callbackValue, &context->callback)) { + context->asyncType = (argc == maxCount) ? CERT_ASYNC_TYPE_CALLBACK : CERT_ASYNC_TYPE_PROMISE; + if (context->asyncType == CERT_ASYNC_TYPE_CALLBACK) { + if (!CertGetCallbackFromJSParams(env, callbackValue, &context->callback)) { LOGE("get callback failed!"); return false; } @@ -126,14 +127,14 @@ NapiX509CrlEntry::NapiX509CrlEntry(HcfX509CrlEntry *x509CrlEntry) NapiX509CrlEntry::~NapiX509CrlEntry() { - OH_HCF_OBJ_DESTROY(this->x509CrlEntry_); + HcfObjDestroy(this->x509CrlEntry_); } static void GetEncodedExecute(napi_env env, void *data) { CfCtx *context = static_cast(data); HcfX509CrlEntry *x509CrlEntry = context->crlEntryClass->GetX509CrlEntry(); - HcfEncodingBlob *encodingBlob = (HcfEncodingBlob *)HcfMalloc(sizeof(HcfEncodingBlob), 0); + HcfEncodingBlob *encodingBlob = static_cast(HcfMalloc(sizeof(HcfEncodingBlob), 0)); if (encodingBlob == nullptr) { LOGE("malloc encoding blob failed!"); context->errCode = HCF_ERR_MALLOC; @@ -162,80 +163,13 @@ static void GetEncodedComplete(napi_env env, napi_status status, void *data) FreeCryptoFwkCtx(env, context); } -static void GetCertificateIssuerExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509CrlEntry *x509CrlEntry = context->crlEntryClass->GetX509CrlEntry(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); - if (blob == nullptr) { - LOGE("malloc blob failed!"); - context->errCode = HCF_ERR_MALLOC; - context->errMsg = "malloc blob failed"; - return; - } - - context->errCode = x509CrlEntry->getCertIssuer(x509CrlEntry, blob); - if (context->errCode != HCF_SUCCESS) { - LOGE("get cert issuer failed!"); - context->errMsg = "get cert issuer failed"; - } - context->blob = blob; -} - -static void GetCertificateIssuerComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - napi_value returnBlob = ConvertBlobToNapiValue(env, context->blob); - ReturnResult(env, context, returnBlob); - FreeCryptoFwkCtx(env, context); -} - -static void GetRevocationDateExecute(napi_env env, void *data) -{ - CfCtx *context = static_cast(data); - HcfX509CrlEntry *x509CrlEntry = context->crlEntryClass->GetX509CrlEntry(); - HcfBlob *blob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); - if (blob == nullptr) { - LOGE("malloc blob failed!"); - context->errCode = HCF_ERR_MALLOC; - context->errMsg = "malloc blob failed"; - return; - } - context->errCode = x509CrlEntry->getRevocationDate(x509CrlEntry, blob); - if (context->errCode != HCF_SUCCESS) { - LOGE("get revocation date failed!"); - context->errMsg = "get revocation date failed"; - } - context->blob = blob; -} - -static void GetRevocationDateComplete(napi_env env, napi_status status, void *data) -{ - CfCtx *context = static_cast(data); - if (context->errCode != HCF_SUCCESS) { - ReturnResult(env, context, nullptr); - FreeCryptoFwkCtx(env, context); - return; - } - HcfBlob *blob = context->blob; - napi_value result = nullptr; - napi_create_string_utf8(env, (char *)blob->data, blob->len, &result); - ReturnResult(env, context, result); - FreeCryptoFwkCtx(env, context); -} - napi_value NapiX509CrlEntry::GetEncoded(napi_env env, napi_callback_info info) { size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { + if (!CertCheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } @@ -252,108 +186,82 @@ napi_value NapiX509CrlEntry::GetEncoded(napi_env env, napi_callback_info info) } napi_create_async_work( - env, nullptr, GetResourceName(env, "GetEncoded"), + env, nullptr, CertGetResourceName(env, "GetEncoded"), GetEncodedExecute, GetEncodedComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { + if (context->asyncType == CERT_ASYNC_TYPE_PROMISE) { return context->promise; } else { - return NapiGetNull(env); + return CertNapiGetNull(env); } } napi_value NapiX509CrlEntry::GetSerialNumber(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ZERO; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { + HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry(); + HcfBlob blob = { nullptr, 0 }; + HcfResult ret = x509CrlEntry->getSerialNumber(x509CrlEntry, &blob); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "crl entry get serial num failed")); + LOGE("crl entry get serial num failed!"); return nullptr; } - HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry(); - long serialNumber = x509CrlEntry->getSerialNumber(x509CrlEntry); - napi_value result = nullptr; - napi_create_int64(env, serialNumber, &result); + napi_value result = ConvertBlobToBigIntWords(env, blob); + HcfBlobDataFree(&blob); return result; } napi_value NapiX509CrlEntry::GetCertificateIssuer(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { - return nullptr; - } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); + if (blob == nullptr) { + LOGE("malloc blob failed!"); return nullptr; } - context->crlEntryClass = this; - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_ONE, argv[PARAM0])) { - FreeCryptoFwkCtx(env, context); + HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry(); + HcfResult ret = x509CrlEntry->getCertIssuer(x509CrlEntry, blob); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "get subject name failed")); + LOGE("get cert issuer failed!"); + HcfFree(blob); + blob = nullptr; return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetCertificateIssuer"), - GetCertificateIssuerExecute, - GetCertificateIssuerComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value returnValue = CertConvertBlobToNapiValue(env, blob); + HcfBlobDataFree(blob); + HcfFree(blob); + blob = nullptr; + return returnValue; } napi_value NapiX509CrlEntry::GetRevocationDate(napi_env env, napi_callback_info info) { - size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { - return nullptr; - } - - CfCtx *context = static_cast(HcfMalloc(sizeof(CfCtx), 0)); - if (context == nullptr) { - LOGE("malloc context failed!"); - FreeCryptoFwkCtx(env, context); + HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry(); + HcfBlob *blob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); + if (blob == nullptr) { + LOGE("malloc blob failed!"); return nullptr; } - context->crlEntryClass = this; - - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_ONE, argv[PARAM0])) { - FreeCryptoFwkCtx(env, context); + HcfResult ret = x509CrlEntry->getRevocationDate(x509CrlEntry, blob); + if (ret != HCF_SUCCESS) { + napi_throw(env, CertGenerateBusinessError(env, ret, "get revocation date failed")); + LOGE("get revocation date failed!"); + HcfFree(blob); + blob = nullptr; return nullptr; } - - napi_create_async_work( - env, nullptr, GetResourceName(env, "GetRevocationDate"), - GetRevocationDateExecute, - GetRevocationDateComplete, - (void *)context, - &context->asyncWork); - - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); - } + napi_value returnDate = nullptr; + napi_create_string_utf8(env, reinterpret_cast(blob->data), blob->len, &returnDate); + HcfBlobDataFree(blob); + HcfFree(blob); + blob = nullptr; + return returnDate; } static napi_value NapiGetEncoded(napi_env env, napi_callback_info info) @@ -437,5 +345,5 @@ napi_value NapiX509CrlEntry::CreateX509CrlEntry(napi_env env) napi_new_instance(env, constructor, 0, nullptr, &instance); return instance; } -} // namespace CryptoFramework +} // namespace CertFramework } // namespace OHOS diff --git a/frameworks/js/napi/crypto/BUILD.gn b/frameworks/js/napi/crypto/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..c113fd1e4c591b958b8285f19729be7bd312eed2 --- /dev/null +++ b/frameworks/js/napi/crypto/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (C) 2022 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/ohos.gni") + +ohos_shared_library("cryptoframework_napi") { + subsystem_name = "security" + part_name = "crypto_framework" + relative_install_dir = "module/security" + include_dirs = [ + "//third_party/bounds_checking_function/include", + "//commonlibrary/c_utils/base/include", + "//base/security/crypto_framework/frameworks/js/napi/crypto/inc", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + ] + include_dirs += framework_inc_path + + if (os_level == "standard") { + sanitize = { + cfi = true + debug = false + blocklist = "//base/security/crypto_framework/cfi_blocklist.txt" + } + } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-g3", + ] + + sources = [ + "src/napi_asy_key_generator.cpp", + "src/napi_cipher.cpp", + "src/napi_init.cpp", + "src/napi_key.cpp", + "src/napi_key_agreement.cpp", + "src/napi_key_pair.cpp", + "src/napi_mac.cpp", + "src/napi_md.cpp", + "src/napi_pri_key.cpp", + "src/napi_pub_key.cpp", + "src/napi_rand.cpp", + "src/napi_sign.cpp", + "src/napi_sym_key.cpp", + "src/napi_sym_key_generator.cpp", + "src/napi_utils.cpp", + "src/napi_verify.cpp", + ] + + deps = [ + "//base/security/crypto_framework/frameworks:crypto_framework_lib", + "//third_party/bounds_checking_function:libsec_shared", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "napi:ace_napi", + ] +} diff --git a/frameworks/js/napi/inc/napi_asy_key_generator.h b/frameworks/js/napi/crypto/inc/napi_asy_key_generator.h similarity index 94% rename from frameworks/js/napi/inc/napi_asy_key_generator.h rename to frameworks/js/napi/crypto/inc/napi_asy_key_generator.h index 620707da96414c9686fa58328f80e9a8ea08af6a..39923aec188a41d6ac226c92ba439a2fc34ff3d6 100644 --- a/frameworks/js/napi/inc/napi_asy_key_generator.h +++ b/frameworks/js/napi/crypto/inc/napi_asy_key_generator.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_ASY_KEY_GENERATOR_H #define HCF_NAPI_ASY_KEY_GENERATOR_H -#include +#include #include "asy_key_generator.h" #include "log.h" #include "napi/native_api.h" @@ -26,7 +26,7 @@ namespace OHOS { namespace CryptoFramework { class NapiAsyKeyGenerator { public: - NapiAsyKeyGenerator(HcfAsyKeyGenerator *generator); + explicit NapiAsyKeyGenerator(HcfAsyKeyGenerator *generator); ~NapiAsyKeyGenerator(); HcfAsyKeyGenerator *GetAsyKeyGenerator(); diff --git a/frameworks/js/napi/inc/napi_cipher.h b/frameworks/js/napi/crypto/inc/napi_cipher.h similarity index 95% rename from frameworks/js/napi/inc/napi_cipher.h rename to frameworks/js/napi/crypto/inc/napi_cipher.h index 14e0773f00ae9dd9daeeb6fd76e6bcf691524aea..6c36b67001ff02640d7fceb05a07a945ddda5525 100644 --- a/frameworks/js/napi/inc/napi_cipher.h +++ b/frameworks/js/napi/crypto/inc/napi_cipher.h @@ -27,7 +27,7 @@ namespace OHOS { namespace CryptoFramework { class NapiCipher { public: - NapiCipher(HcfCipher *cipher); + explicit NapiCipher(HcfCipher *cipher); ~NapiCipher(); static void DefineCipherJSClass(napi_env env, napi_value exports); @@ -38,7 +38,7 @@ public: static napi_value JsCipherUpdate(napi_env env, napi_callback_info info); static napi_value JsCipherDoFinal(napi_env env, napi_callback_info info); static napi_value JsGetAlgorithm(napi_env env, napi_callback_info info); - HcfCipher *GetCipher(); + HcfCipher *GetCipher() const; static thread_local napi_ref classRef_; private: diff --git a/frameworks/js/napi/inc/napi_crypto_framework_defines.h b/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h similarity index 75% rename from frameworks/js/napi/inc/napi_crypto_framework_defines.h rename to frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h index f9fb9b74276d9e0eb3c4b40559196445d6a7a2d7..ae2dcd3c1da57b61a355202d376221c695ac753e 100644 --- a/frameworks/js/napi/inc/napi_crypto_framework_defines.h +++ b/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h @@ -16,12 +16,11 @@ #ifndef NAPI_CRYPTO_FRAMEWORK_DEFINES_H #define NAPI_CRYPTO_FRAMEWORK_DEFINES_H -#include +#include namespace OHOS { namespace CryptoFramework { constexpr size_t CALLBACK_SIZE = 1; -constexpr size_t ARGS_SIZE_ZERO = 0; constexpr size_t ARGS_SIZE_ONE = 1; constexpr size_t ARGS_SIZE_TWO = 2; constexpr size_t ARGS_SIZE_THREE = 3; @@ -35,20 +34,12 @@ constexpr uint32_t JS_ERR_DEFAULT_ERR = 0; constexpr uint32_t JS_ERR_INVALID_PARAMS = 401; constexpr uint32_t JS_ERR_NOT_SUPPORT = 801; constexpr uint32_t JS_ERR_OUT_OF_MEMORY = 17620001; -constexpr uint32_t JS_ERR_INTERNAL_ERROR = 17620002; +constexpr uint32_t JS_ERR_RUNTIME_ERROR = 17620002; constexpr uint32_t JS_ERR_CRYPTO_OPERATION = 17630001; -constexpr uint32_t JS_ERR_CERT_SIGNATURE_FAILURE = 17630002; -constexpr uint32_t JS_ERR_CERT_NOT_YET_VALID = 17630003; -constexpr uint32_t JS_ERR_CERT_HAS_EXPIRED = 17630004; -constexpr uint32_t JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 17630005; -constexpr uint32_t JS_ERR_KEYUSAGE_NO_CERTSIGN = 17630006; -constexpr uint32_t JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = 17630007; + const std::string CRYPTO_TAG_DATA = "data"; const std::string CRYPTO_TAG_ERR_CODE = "code"; const std::string CRYPTO_TAG_ERR_MSG = "message"; -const std::string CRYPTO_TAG_COUNT = "count"; -const std::string CRYPTO_TAG_ENCODING_FORMAT = "encodingFormat"; -const std::string CRYPTO_TAG_ALGORITHM = "algorithm"; const std::string CRYPTO_TAG_ALG_NAME = "algName"; const std::string CRYPTO_TAG_FORMAT = "format"; const std::string CRYPTO_TAG_PUB_KEY = "pubKey"; @@ -56,7 +47,8 @@ const std::string CRYPTO_TAG_PRI_KEY = "priKey"; const std::string IV_PARAMS = "iv"; const std::string AAD_PARAMS = "aad"; const std::string AUTHTAG_PARAMS = "authTag"; -const std::string ALGO_PARAMS = "algoName"; +const std::string ALGO_PARAMS = "algName"; +const std::string ALGO_PARAMS_OLD = "algoName"; const std::string IV_PARAMS_SPEC = "IvParamsSpec"; const std::string GCM_PARAMS_SPEC = "GcmParamsSpec"; const std::string CCM_PARAMS_SPEC = "CcmParamsSpec"; diff --git a/frameworks/js/napi/inc/napi_key.h b/frameworks/js/napi/crypto/inc/napi_key.h similarity index 89% rename from frameworks/js/napi/inc/napi_key.h rename to frameworks/js/napi/crypto/inc/napi_key.h index 4213312f4b8aa810bd0d738b6e9452cdfc212b82..54e849fd296de4ced697ce0a8ee95ae1a6be666d 100644 --- a/frameworks/js/napi/inc/napi_key.h +++ b/frameworks/js/napi/crypto/inc/napi_key.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_HCF_KEY_H #define HCF_NAPI_HCF_KEY_H -#include +#include #include "log.h" #include "napi/native_api.h" #include "napi/native_node_api.h" @@ -26,12 +26,11 @@ namespace OHOS { namespace CryptoFramework { class NapiKey { public: - NapiKey(HcfKey *symKey); - ~NapiKey(); - HcfKey *GetHcfKey(); + explicit NapiKey(HcfKey *hcfKey); + virtual ~NapiKey(); + HcfKey *GetHcfKey() const; static void DefineHcfKeyJSClass(napi_env env); - static napi_value CreateHcfKey(napi_env env); static napi_value KeyConstructor(napi_env env, napi_callback_info info); static napi_value JsGetAlgorithm(napi_env env, napi_callback_info info); @@ -39,7 +38,7 @@ public: static napi_value JsGetFormat(napi_env env, napi_callback_info info); static thread_local napi_ref classRef_; -private: +protected: HcfKey *hcfKey_; }; } // namespace CryptoFramework diff --git a/frameworks/js/napi/inc/napi_key_agreement.h b/frameworks/js/napi/crypto/inc/napi_key_agreement.h similarity index 94% rename from frameworks/js/napi/inc/napi_key_agreement.h rename to frameworks/js/napi/crypto/inc/napi_key_agreement.h index 94e24916cff29599e545687bad86aa11a2678327..7d3529a6361e968dd3bad6fbdbe0cd7217b8e791 100644 --- a/frameworks/js/napi/inc/napi_key_agreement.h +++ b/frameworks/js/napi/crypto/inc/napi_key_agreement.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_KEY_AGREEMENT_H #define HCF_NAPI_KEY_AGREEMENT_H -#include +#include #include "log.h" #include "key_agreement.h" #include "napi/native_api.h" @@ -26,7 +26,7 @@ namespace OHOS { namespace CryptoFramework { class NapiKeyAgreement { public: - NapiKeyAgreement(HcfKeyAgreement *keyAgreement); + explicit NapiKeyAgreement(HcfKeyAgreement *keyAgreement); ~NapiKeyAgreement(); HcfKeyAgreement *GetKeyAgreement(); diff --git a/frameworks/js/napi/inc/napi_key_pair.h b/frameworks/js/napi/crypto/inc/napi_key_pair.h similarity index 94% rename from frameworks/js/napi/inc/napi_key_pair.h rename to frameworks/js/napi/crypto/inc/napi_key_pair.h index a08e7644b69f649dbfd9ee62b5bac4bc7924bedd..e5db6c0965f50dee8d88d0f31034312568d3b990 100644 --- a/frameworks/js/napi/inc/napi_key_pair.h +++ b/frameworks/js/napi/crypto/inc/napi_key_pair.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_KEY_PAIR_H #define HCF_NAPI_KEY_PAIR_H -#include +#include #include "log.h" #include "key_pair.h" #include "napi/native_api.h" @@ -26,7 +26,7 @@ namespace OHOS { namespace CryptoFramework { class NapiKeyPair { public: - NapiKeyPair(HcfKeyPair *keyPair); + explicit NapiKeyPair(HcfKeyPair *keyPair); ~NapiKeyPair(); napi_value ConvertToJsKeyPair(napi_env env); diff --git a/frameworks/js/napi/inc/napi_mac.h b/frameworks/js/napi/crypto/inc/napi_mac.h similarity index 94% rename from frameworks/js/napi/inc/napi_mac.h rename to frameworks/js/napi/crypto/inc/napi_mac.h index 0af1c42d6b1f8b1b228b12e9be6666b07e547381..3e979f9e0c53af163b577e059255ff0f2b55681a 100644 --- a/frameworks/js/napi/inc/napi_mac.h +++ b/frameworks/js/napi/crypto/inc/napi_mac.h @@ -28,9 +28,9 @@ namespace OHOS { namespace CryptoFramework { class NapiMac { public: - NapiMac(HcfMac *macObj); + explicit NapiMac(HcfMac *macObj); ~NapiMac(); - static napi_ref classRef_; + static thread_local napi_ref classRef_; static void DefineMacJSClass(napi_env env, napi_value exports); static napi_value CreateMac(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/inc/napi_md.h b/frameworks/js/napi/crypto/inc/napi_md.h similarity index 94% rename from frameworks/js/napi/inc/napi_md.h rename to frameworks/js/napi/crypto/inc/napi_md.h index 158eec336b511eaad5b9bed3ebf8430e66bbb5ad..50f5d49ccb3d4b10eb2493d2b40097f9034a069b 100644 --- a/frameworks/js/napi/inc/napi_md.h +++ b/frameworks/js/napi/crypto/inc/napi_md.h @@ -28,9 +28,9 @@ namespace OHOS { namespace CryptoFramework { class NapiMd { public: - NapiMd(HcfMd *mdObj); + explicit NapiMd(HcfMd *mdObj); ~NapiMd(); - static napi_ref classRef_; + static thread_local napi_ref classRef_; static void DefineMdJSClass(napi_env env, napi_value exports); static napi_value CreateMd(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/inc/napi_pri_key.h b/frameworks/js/napi/crypto/inc/napi_pri_key.h similarity index 89% rename from frameworks/js/napi/inc/napi_pri_key.h rename to frameworks/js/napi/crypto/inc/napi_pri_key.h index df3447d289545993cb05c2de27baec622ed850d9..b87dd948d16898abb787d60ae7d093532013fb45 100644 --- a/frameworks/js/napi/inc/napi_pri_key.h +++ b/frameworks/js/napi/crypto/inc/napi_pri_key.h @@ -16,18 +16,19 @@ #ifndef HCF_NAPI_PRI_KEY_H #define HCF_NAPI_PRI_KEY_H -#include +#include #include "log.h" #include "pri_key.h" +#include "napi_key.h" #include "napi/native_api.h" #include "napi/native_node_api.h" namespace OHOS { namespace CryptoFramework { -class NapiPriKey { +class NapiPriKey : public NapiKey { public: - NapiPriKey(HcfPriKey *priKey); - ~NapiPriKey(); + explicit NapiPriKey(HcfPriKey *priKey); + ~NapiPriKey() override; HcfPriKey *GetPriKey(); napi_value ConvertToJsPriKey(napi_env env); @@ -39,9 +40,6 @@ public: static napi_value JsClearMem(napi_env env, napi_callback_info info); static thread_local napi_ref classRef_; - -private: - HcfPriKey *priKey_ = nullptr; }; } // namespace CryptoFramework } // namespace OHOS diff --git a/frameworks/js/napi/inc/napi_pub_key.h b/frameworks/js/napi/crypto/inc/napi_pub_key.h similarity index 89% rename from frameworks/js/napi/inc/napi_pub_key.h rename to frameworks/js/napi/crypto/inc/napi_pub_key.h index eee18000d37f0b5930442cb1f839cafa2278fcec..389aaca587cb8172b811d1dbc4b2adb932503984 100644 --- a/frameworks/js/napi/inc/napi_pub_key.h +++ b/frameworks/js/napi/crypto/inc/napi_pub_key.h @@ -16,18 +16,19 @@ #ifndef HCF_NAPI_PUB_KEY_H #define HCF_NAPI_PUB_KEY_H -#include +#include #include "log.h" #include "pub_key.h" +#include "napi_key.h" #include "napi/native_api.h" #include "napi/native_node_api.h" namespace OHOS { namespace CryptoFramework { -class NapiPubKey { +class NapiPubKey : public NapiKey { public: - NapiPubKey(HcfPubKey *pubKey); - ~NapiPubKey(); + explicit NapiPubKey(HcfPubKey *pubKey); + ~NapiPubKey() override; HcfPubKey *GetPubKey(); napi_value ConvertToJsPubKey(napi_env env); @@ -38,9 +39,6 @@ public: static napi_value JsGetEncoded(napi_env env, napi_callback_info info); static thread_local napi_ref classRef_; - -private: - HcfPubKey *pubKey_ = nullptr; }; } // namespace CryptoFramework } // namespace OHOS diff --git a/frameworks/js/napi/inc/napi_rand.h b/frameworks/js/napi/crypto/inc/napi_rand.h similarity index 94% rename from frameworks/js/napi/inc/napi_rand.h rename to frameworks/js/napi/crypto/inc/napi_rand.h index a4b2ebfa34d373de9114dc903aeaf49e8e617538..927ada84f88068646337371a5b3269027e64330e 100644 --- a/frameworks/js/napi/inc/napi_rand.h +++ b/frameworks/js/napi/crypto/inc/napi_rand.h @@ -28,9 +28,9 @@ namespace OHOS { namespace CryptoFramework { class NapiRand { public: - NapiRand(HcfRand *randObj); + explicit NapiRand(HcfRand *randObj); ~NapiRand(); - static napi_ref classRef_; + static thread_local napi_ref classRef_; static void DefineRandJSClass(napi_env env, napi_value exports); static napi_value CreateRand(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/inc/napi_sign.h b/frameworks/js/napi/crypto/inc/napi_sign.h similarity index 96% rename from frameworks/js/napi/inc/napi_sign.h rename to frameworks/js/napi/crypto/inc/napi_sign.h index b1557d1f89dd4b4a0f5257067cb0747e20cf2826..e4f77763f4ba7ddc5b1ed82ef97b651c51bee122 100644 --- a/frameworks/js/napi/inc/napi_sign.h +++ b/frameworks/js/napi/crypto/inc/napi_sign.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_SIGNATURE_H #define HCF_NAPI_SIGNATURE_H -#include +#include #include "log.h" #include "signature.h" #include "napi/native_api.h" @@ -26,7 +26,7 @@ namespace OHOS { namespace CryptoFramework { class NapiSign { public: - NapiSign(HcfSign *sign); + explicit NapiSign(HcfSign *sign); ~NapiSign(); HcfSign *GetSign(); diff --git a/frameworks/js/napi/inc/napi_sym_key.h b/frameworks/js/napi/crypto/inc/napi_sym_key.h similarity index 74% rename from frameworks/js/napi/inc/napi_sym_key.h rename to frameworks/js/napi/crypto/inc/napi_sym_key.h index 88c4f98962b70f6f0d0121873847a0a5c5d4cb07..a0613b0ec7eaee008653a4cd53d9dc2676f79926 100644 --- a/frameworks/js/napi/inc/napi_sym_key.h +++ b/frameworks/js/napi/crypto/inc/napi_sym_key.h @@ -16,31 +16,27 @@ #ifndef HCF_NAPI_SYM_KEY_H #define HCF_NAPI_SYM_KEY_H -#include +#include #include "log.h" +#include "napi_key.h" #include "napi/native_api.h" #include "napi/native_node_api.h" #include "sym_key.h" namespace OHOS { namespace CryptoFramework { -class NapiSymKey { +class NapiSymKey : public NapiKey { public: - NapiSymKey(HcfSymKey *symKey); - ~NapiSymKey(); - HcfSymKey *GetSymKey(); + explicit NapiSymKey(HcfSymKey *symKey); + ~NapiSymKey() override; + HcfSymKey *GetSymKey() const; static void DefineSymKeyJSClass(napi_env env); static napi_value CreateSymKey(napi_env env); static napi_value SymKeyConstructor(napi_env env, napi_callback_info info); - - static napi_value JsGetAlgorithm(napi_env env, napi_callback_info info); - static napi_value JsGetEncoded(napi_env env, napi_callback_info info); - static napi_value JsGetFormat(napi_env env, napi_callback_info info); + static napi_value JsClearMem(napi_env env, napi_callback_info info); static thread_local napi_ref classRef_; -private: - HcfSymKey *symKey_; }; } // namespace CryptoFramework } // namespace OHOS diff --git a/frameworks/js/napi/inc/napi_sym_key_generator.h b/frameworks/js/napi/crypto/inc/napi_sym_key_generator.h similarity index 91% rename from frameworks/js/napi/inc/napi_sym_key_generator.h rename to frameworks/js/napi/crypto/inc/napi_sym_key_generator.h index 68401eed0f60e0a2551fb82d86c5c641ce309075..92f6591e7782f0d6866d405cf873912c1798b938 100644 --- a/frameworks/js/napi/inc/napi_sym_key_generator.h +++ b/frameworks/js/napi/crypto/inc/napi_sym_key_generator.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_SYM_KEY_GENERATOR_H #define HCF_NAPI_SYM_KEY_GENERATOR_H -#include +#include #include "log.h" #include "napi/native_api.h" #include "napi/native_node_api.h" @@ -26,9 +26,9 @@ namespace OHOS { namespace CryptoFramework { class NapiSymKeyGenerator { public: - NapiSymKeyGenerator(HcfSymKeyGenerator *generator); + explicit NapiSymKeyGenerator(HcfSymKeyGenerator *generator); ~NapiSymKeyGenerator(); - HcfSymKeyGenerator *GetSymKeyGenerator(); + HcfSymKeyGenerator *GetSymKeyGenerator() const; static void DefineSymKeyGeneratorJSClass(napi_env env, napi_value exports); static napi_value CreateSymKeyGenerator(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/inc/napi_utils.h b/frameworks/js/napi/crypto/inc/napi_utils.h similarity index 81% rename from frameworks/js/napi/inc/napi_utils.h rename to frameworks/js/napi/crypto/inc/napi_utils.h index 493b4c77b92d707af5cc9faaee6803b3041e2021..0adb0cb84c1d4287ed6dc9e7db0b02d5a939d994 100644 --- a/frameworks/js/napi/inc/napi_utils.h +++ b/frameworks/js/napi/crypto/inc/napi_utils.h @@ -16,12 +16,11 @@ #ifndef HCF_NAPI_UILTS_H #define HCF_NAPI_UILTS_H -#include +#include #include #include "napi/native_api.h" #include "napi/native_node_api.h" #include "blob.h" -#include "cert_chain_validator.h" #include "algorithm_parameter.h" #include "cipher.h" @@ -52,14 +51,9 @@ bool GetStringFromJSParams(napi_env env, napi_value arg, std::string &returnStr) bool GetInt32FromJSParams(napi_env env, napi_value arg, int32_t &returnInt); bool GetUint32FromJSParams(napi_env env, napi_value arg, uint32_t &returnInt); bool GetCallbackFromJSParams(napi_env env, napi_value arg, napi_ref *returnCb); -bool GetEncodingBlobFromValue(napi_env env, napi_value object, HcfEncodingBlob **encodingBlob); -bool GetCertChainFromValue(napi_env env, napi_value object, HcfCertChainData **certChainData); bool CheckArgsCount(napi_env env, size_t argc, size_t expectedCount, bool isSync); napi_value GetResourceName(napi_env env, const char *name); -napi_value GenerateArrayBuffer(napi_env env, uint8_t *data, uint32_t size); napi_value NapiGetNull(napi_env env); -napi_value ConvertArrayToNapiValue(napi_env env, HcfArray *array); -napi_value ConvertEncodingBlobToNapiValue(napi_env env, HcfEncodingBlob *encodingBlob); napi_value GenerateBusinessError(napi_env env, int32_t errCode, const char *errMsg); } // namespace CryptoFramework } // namespace OHOS diff --git a/frameworks/js/napi/inc/napi_verify.h b/frameworks/js/napi/crypto/inc/napi_verify.h similarity index 95% rename from frameworks/js/napi/inc/napi_verify.h rename to frameworks/js/napi/crypto/inc/napi_verify.h index ac0aec976eb272c14ff1652680ab0e4daa61988b..705c067a79bef0caad441b020e5c1fbb1e64be2d 100644 --- a/frameworks/js/napi/inc/napi_verify.h +++ b/frameworks/js/napi/crypto/inc/napi_verify.h @@ -16,7 +16,7 @@ #ifndef HCF_NAPI_VERIFY_H #define HCF_NAPI_VERIFY_H -#include +#include #include "log.h" #include "signature.h" #include "napi/native_api.h" @@ -26,7 +26,7 @@ namespace OHOS { namespace CryptoFramework { class NapiVerify { public: - NapiVerify(HcfVerify *verify); + explicit NapiVerify(HcfVerify *verify); ~NapiVerify(); HcfVerify *GetVerify(); diff --git a/frameworks/js/napi/src/napi_asy_key_generator.cpp b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp similarity index 92% rename from frameworks/js/napi/src/napi_asy_key_generator.cpp rename to frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp index cb57ad3b777aa9343ecdcc04cfc8b07fc6cdc15e..ee947fd6bb5218518c59c344c5d6219fbacfa793 100644 --- a/frameworks/js/napi/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -109,7 +109,7 @@ static bool BuildGenKeyPairCtx(napi_env env, napi_callback_info info, GenKeyPair { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_ONE; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { @@ -120,7 +120,7 @@ static bool BuildGenKeyPairCtx(napi_env env, napi_callback_info info, GenKeyPair ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiAsyKeyGenerator *napiGenerator; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiGenerator)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok) { LOGE("failed to unwrap napi asyKeyGenerator obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -148,7 +148,8 @@ static bool GetPkAndSkBlobFromNapiValueIfInput(napi_env env, napi_value pkValue, pubKey = GetBlobFromNapiValue(env, pkValue); if (pubKey == nullptr) { LOGE("failed to get pubKey."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PubKey]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "[PubKey]: must be of the DataBlob type.")); return false; } } @@ -159,7 +160,8 @@ static bool GetPkAndSkBlobFromNapiValueIfInput(napi_env env, napi_value pkValue, priKey = GetBlobFromNapiValue(env, skValue); if (priKey == nullptr) { LOGE("failed to get priKey."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PriKey]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "[PriKey]: must be of the DataBlob type.")); return false; } } @@ -173,7 +175,7 @@ static bool BuildConvertKeyCtx(napi_env env, napi_callback_info info, ConvertKey { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_THREE; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_THREE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { @@ -184,7 +186,7 @@ static bool BuildConvertKeyCtx(napi_env env, napi_callback_info info, ConvertKey ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiAsyKeyGenerator *napiGenerator; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiGenerator)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok) { LOGE("failed to unwrap napi asyKeyGenerator obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -233,7 +235,8 @@ static void ReturnGenKeyPairPromiseResult(napi_env env, GenKeyPairCtx *ctx, napi if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, + GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); } } @@ -260,7 +263,8 @@ static void ReturnConvertKeyPromiseResult(napi_env env, ConvertKeyCtx *ctx, napi if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, + GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); } } @@ -358,7 +362,7 @@ static napi_value NewGenKeyPairAsyncWork(napi_env env, GenKeyPairCtx *ctx) GenKeyPairAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -386,7 +390,7 @@ static napi_value NewConvertKeyAsyncWork(napi_env env, ConvertKeyCtx *ctx) ConvertKeyAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -406,7 +410,7 @@ NapiAsyKeyGenerator::NapiAsyKeyGenerator(HcfAsyKeyGenerator *generator) NapiAsyKeyGenerator::~NapiAsyKeyGenerator() { - OH_HCF_OBJ_DESTROY(this->generator_); + HcfObjDestroy(this->generator_); } HcfAsyKeyGenerator *NapiAsyKeyGenerator::GetAsyKeyGenerator() @@ -417,11 +421,11 @@ HcfAsyKeyGenerator *NapiAsyKeyGenerator::GetAsyKeyGenerator() napi_value NapiAsyKeyGenerator::JsGenerateKeyPair(napi_env env, napi_callback_info info) { LOGI("enter ..."); - GenKeyPairCtx *ctx = (GenKeyPairCtx *)HcfMalloc(sizeof(GenKeyPairCtx), 0); - if (ctx == NULL) { + GenKeyPairCtx *ctx = static_cast(HcfMalloc(sizeof(GenKeyPairCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc ctx fail.")); - return NULL; + return nullptr; } if (!BuildGenKeyPairCtx(env, info, ctx)) { @@ -436,10 +440,10 @@ napi_value NapiAsyKeyGenerator::JsGenerateKeyPair(napi_env env, napi_callback_in napi_value NapiAsyKeyGenerator::JsConvertKey(napi_env env, napi_callback_info info) { LOGI("enter ..."); - ConvertKeyCtx *ctx = (ConvertKeyCtx *)HcfMalloc(sizeof(ConvertKeyCtx), 0); - if (ctx == NULL) { + ConvertKeyCtx *ctx = static_cast(HcfMalloc(sizeof(ConvertKeyCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildConvertKeyCtx(env, info, ctx)) { @@ -465,12 +469,12 @@ napi_value NapiAsyKeyGenerator::AsyKeyGeneratorConstructor(napi_env env, napi_ca napi_value NapiAsyKeyGenerator::CreateJsAsyKeyGenerator(napi_env env, napi_callback_info info) { LOGI("enter ..."); - size_t exceptedArgc = PARAMS_NUM_ONE; - size_t argc; + size_t expectedArgc = PARAMS_NUM_ONE; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return NapiGetNull(env); } @@ -486,7 +490,7 @@ napi_value NapiAsyKeyGenerator::CreateJsAsyKeyGenerator(napi_env env, napi_callb return NapiGetNull(env); } - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate(algName.c_str(), &generator); if (res != HCF_SUCCESS) { LOGE("create c generator fail."); @@ -498,7 +502,7 @@ napi_value NapiAsyKeyGenerator::CreateJsAsyKeyGenerator(napi_env env, napi_callb napi_wrap( env, instance, napiAsyKeyGenerator, [](napi_env env, void *data, void *hint) { - NapiAsyKeyGenerator *napiAsyKeyGenerator = (NapiAsyKeyGenerator *)(data); + NapiAsyKeyGenerator *napiAsyKeyGenerator = static_cast(data); delete napiAsyKeyGenerator; return; }, diff --git a/frameworks/js/napi/src/napi_cipher.cpp b/frameworks/js/napi/crypto/src/napi_cipher.cpp similarity index 90% rename from frameworks/js/napi/src/napi_cipher.cpp rename to frameworks/js/napi/crypto/src/napi_cipher.cpp index 86434326c4356725dd4c1655de7b71d5526c192d..ce22b36a0a8765f5c5a7717093498c83e106e5b8 100644 --- a/frameworks/js/napi/src/napi_cipher.cpp +++ b/frameworks/js/napi/crypto/src/napi_cipher.cpp @@ -41,8 +41,8 @@ struct CipherFwkCtxT { HcfCipher *cipher = nullptr; HcfKey *key = nullptr; HcfParamsSpec *paramsSpec = nullptr; - HcfBlob input = { 0 }; - HcfBlob output = { 0 }; + HcfBlob input = { .data = nullptr, .len = 0 }; + HcfBlob output = { .data = nullptr, .len = 0 }; enum HcfCryptoMode opMode = ENCRYPT_MODE; int32_t errCode = 0; @@ -57,13 +57,13 @@ static void FreeParamsSpec(HcfParamsSpec *paramsSpec) return; } if (IV_PARAMS_SPEC.compare(paramsSpec->getType()) == 0) { - HcfIvParamsSpec *iv = (HcfIvParamsSpec *)paramsSpec; + HcfIvParamsSpec *iv = reinterpret_cast(paramsSpec); HcfFree(iv->iv.data); iv->iv.data = nullptr; iv->iv.len = 0; } if (GCM_PARAMS_SPEC.compare(paramsSpec->getType()) == 0) { - HcfGcmParamsSpec *gcm = (HcfGcmParamsSpec *)paramsSpec; + HcfGcmParamsSpec *gcm = reinterpret_cast(paramsSpec); HcfFree(gcm->iv.data); HcfFree(gcm->aad.data); HcfFree(gcm->tag.data); @@ -75,7 +75,7 @@ static void FreeParamsSpec(HcfParamsSpec *paramsSpec) gcm->tag.data = nullptr; } if (CCM_PARAMS_SPEC.compare(paramsSpec->getType()) == 0) { - HcfCcmParamsSpec *ccm = (HcfCcmParamsSpec *)paramsSpec; + HcfCcmParamsSpec *ccm = reinterpret_cast(paramsSpec); HcfFree(ccm->iv.data); HcfFree(ccm->aad.data); HcfFree(ccm->tag.data); @@ -140,7 +140,7 @@ bool BuildContextForInit(napi_env env, napi_callback_info info, CipherFwkCtx con } context->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - napi_status status = napi_unwrap(env, thisVar, (void **)&napiCipher); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiCipher)); if (status != napi_ok) { LOGE("failed to unwrap napi napiCipher obj!"); return false; @@ -148,15 +148,15 @@ bool BuildContextForInit(napi_env env, napi_callback_info info, CipherFwkCtx con context->cipher = napiCipher->GetCipher(); // get opMode, type is uint32 - size_t index = ARGS_SIZE_ZERO; - if (napi_get_value_uint32(env, argv[index++], (uint32_t *)&(context->opMode)) != napi_ok) { + size_t index = 0; + if (napi_get_value_uint32(env, argv[index++], reinterpret_cast(&(context->opMode))) != napi_ok) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get opMode failed!")); LOGE("get opMode failed!"); return false; } // get key, unwrap from JS - status = napi_unwrap(env, argv[index++], (void **)&napiKey); + status = napi_unwrap(env, argv[index++], reinterpret_cast(&napiKey)); if (status != napi_ok) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap napi napiSymKey obj!")); LOGE("failed to unwrap napi napiSymKey obj!"); @@ -199,7 +199,7 @@ bool BuildContextForUpdate(napi_env env, napi_callback_info info, CipherFwkCtx c } context->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - napi_status status = napi_unwrap(env, thisVar, (void **)&napiCipher); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiCipher)); if (status != napi_ok) { LOGE("failed to unwrap napi napiCipher obj!"); return false; @@ -207,7 +207,7 @@ bool BuildContextForUpdate(napi_env env, napi_callback_info info, CipherFwkCtx c context->cipher = napiCipher->GetCipher(); // get input, type is blob - size_t index = ARGS_SIZE_ZERO; + size_t index = 0; HcfBlob *input = nullptr; input = GetBlobFromNapiValue(env, argv[index++]); if (input == nullptr) { @@ -235,13 +235,14 @@ bool BuildContextForFinal(napi_env env, napi_callback_info info, CipherFwkCtx co napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "doFinal failed for invalid input blob.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "doFinal failed for invalid input blob.")); LOGE("wrong argument num. require 1 or 2 arguments. [Argc]: %zu!", argc); return false; } context->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - napi_status status = napi_unwrap(env, thisVar, (void **)&napiCipher); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiCipher)); if (status != napi_ok) { LOGE("failed to unwrap napi napiCipher obj!"); return false; @@ -249,14 +250,15 @@ bool BuildContextForFinal(napi_env env, napi_callback_info info, CipherFwkCtx co context->cipher = napiCipher->GetCipher(); // get input, type is blob - size_t index = ARGS_SIZE_ZERO; + size_t index = 0; napi_valuetype valueType; napi_typeof(env, argv[index], &valueType); if (valueType != napi_null) { HcfBlob *input = nullptr; input = GetBlobFromNapiValue(env, argv[index]); if (input == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "doFinal failed for invalid input blob.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "doFinal failed for invalid input blob.")); LOGE("GetBlobFromNapiValue failed!"); return false; } @@ -295,7 +297,8 @@ static void ReturnPromiseResult(napi_env env, CipherFwkCtx context, napi_value r if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + GenerateBusinessError(env, context->errCode, context->errMsg)); } } @@ -312,7 +315,7 @@ void AsyncInitProcess(napi_env env, void *data) HcfResult res = cipher->init(cipher, context->opMode, key, params); if (res != HCF_SUCCESS) { - LOGE("init ret:%d", (int32_t)res); + LOGE("init ret:%d", res); context->errCode = res; context->errMsg = "init failed."; return; @@ -330,7 +333,7 @@ void AsyncUpdateProcess(napi_env env, void *data) HcfCipher *cipher = context->cipher; HcfResult res = cipher->update(cipher, &context->input, &context->output); if (res != HCF_SUCCESS) { - LOGE("Update ret:%d!", (int32_t)res); + LOGE("Update ret:%d!", res); context->errCode = res; context->errMsg = "update failed."; return; @@ -348,7 +351,7 @@ void AsyncDoFinalProcess(napi_env env, void *data) HcfResult res = cipher->doFinal(cipher, &context->input, &context->output); if (res != HCF_SUCCESS) { - LOGE("doFinal ret:%d!", (int32_t)res); + LOGE("doFinal ret:%d!", res); context->errCode = res; context->errMsg = "doFinal failed."; return; @@ -428,7 +431,7 @@ napi_value NewAsyncInit(napi_env env, CipherFwkCtx context) AsyncInitReturn(env, status, data); return; }, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); @@ -454,7 +457,7 @@ napi_value NewAsyncUpdate(napi_env env, CipherFwkCtx context) AsyncUpdateReturn(env, status, data); return; }, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); @@ -480,7 +483,7 @@ napi_value NewAsyncDoFinal(napi_env env, CipherFwkCtx context) AsyncDoFinalReturn(env, status, data); return; }, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); @@ -498,17 +501,17 @@ NapiCipher::NapiCipher(HcfCipher *cipher) NapiCipher::~NapiCipher() { - OH_HCF_OBJ_DESTROY(this->cipher_); + HcfObjDestroy(this->cipher_); } -HcfCipher *NapiCipher::GetCipher() +HcfCipher *NapiCipher::GetCipher() const { return this->cipher_; } napi_value NapiCipher::JsCipherInit(napi_env env, napi_callback_info info) { - CipherFwkCtx context = (CipherFwkCtx)HcfMalloc(sizeof(CipherFwkCtxT), 0); + CipherFwkCtx context = static_cast(HcfMalloc(sizeof(CipherFwkCtxT), 0)); if (context == nullptr) { LOGE("create context fail!"); return nullptr; @@ -525,7 +528,7 @@ napi_value NapiCipher::JsCipherInit(napi_env env, napi_callback_info info) napi_value NapiCipher::JsCipherUpdate(napi_env env, napi_callback_info info) { - CipherFwkCtx context = (CipherFwkCtx)HcfMalloc(sizeof(CipherFwkCtxT), 0); + CipherFwkCtx context = static_cast(HcfMalloc(sizeof(CipherFwkCtxT), 0)); if (context == nullptr) { LOGE("create context fail!"); return nullptr; @@ -542,7 +545,7 @@ napi_value NapiCipher::JsCipherUpdate(napi_env env, napi_callback_info info) napi_value NapiCipher::JsCipherDoFinal(napi_env env, napi_callback_info info) { - CipherFwkCtx context = (CipherFwkCtx)HcfMalloc(sizeof(CipherFwkCtxT), 0); + CipherFwkCtx context = static_cast(HcfMalloc(sizeof(CipherFwkCtxT), 0)); if (context == nullptr) { LOGE("create context fail!"); return nullptr; @@ -563,8 +566,7 @@ napi_value NapiCipher::JsGetAlgorithm(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - // get HcfSymKeyGenerator pointer - napi_status status = napi_unwrap(env, thisVar, (void **)&napiCipher); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiCipher)); if (status != napi_ok) { LOGE("failed to unwrap napiCipher obj!"); return nullptr; @@ -579,7 +581,7 @@ napi_value NapiCipher::JsGetAlgorithm(napi_env env, napi_callback_info info) // execute C function const char *algo = cipher->getAlgorithm(cipher); napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)algo, NAPI_AUTO_LENGTH, &instance); + napi_create_string_utf8(env, algo, NAPI_AUTO_LENGTH, &instance); return instance; } @@ -593,12 +595,12 @@ napi_value NapiCipher::CipherConstructor(napi_env env, napi_callback_info info) napi_value NapiCipher::CreateCipher(napi_env env, napi_callback_info info) { - size_t exceptedArgc = ARGS_SIZE_ONE; + size_t expectedArgc = ARGS_SIZE_ONE; size_t argc = ARGS_SIZE_ONE; napi_value argv[ARGS_SIZE_ONE] = { nullptr }; NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "The input args num is invalid.")); LOGE("The input args num is invalid."); return nullptr; @@ -612,7 +614,7 @@ napi_value NapiCipher::CreateCipher(napi_env env, napi_callback_info info) // parse input string std::string algoName; - if (!GetStringFromJSParams(env, argv[ARGS_SIZE_ZERO], algoName)) { + if (!GetStringFromJSParams(env, argv[0], algoName)) { LOGE("GetStringFromJSParams failed!"); return nullptr; } @@ -628,7 +630,7 @@ napi_value NapiCipher::CreateCipher(napi_env env, napi_callback_info info) NapiCipher *napiCipher = new (std::nothrow) NapiCipher(cipher); if (napiCipher == nullptr) { LOGE("new napiCipher failed!"); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); return nullptr; } diff --git a/frameworks/js/napi/src/napi_init.cpp b/frameworks/js/napi/crypto/src/napi_init.cpp similarity index 63% rename from frameworks/js/napi/src/napi_init.cpp rename to frameworks/js/napi/crypto/src/napi_init.cpp index d9ceede93c8cf7f2840613246d046ef0e1823e85..b5932dcbf66737b3cad00b224e067eed730a86d3 100644 --- a/frameworks/js/napi/src/napi_init.cpp +++ b/frameworks/js/napi/crypto/src/napi_init.cpp @@ -15,13 +15,10 @@ #include "securec.h" #include "log.h" -#include "memory.h" -#include "napi_x509_certificate.h" #include "napi_asy_key_generator.h" #include "napi_sym_key_generator.h" #include "napi_cipher.h" -#include "napi_cert_chain_validator.h" #include "napi_key_pair.h" #include "napi_pri_key.h" #include "napi_pub_key.h" @@ -34,31 +31,10 @@ #include "napi_sym_key.h" #include "napi_key.h" #include "napi_utils.h" -#include "napi_x509_crl_entry.h" -#include "napi_x509_crl.h" #include "napi_crypto_framework_defines.h" namespace OHOS { namespace CryptoFramework { -static napi_value CreateEncodingFormat(napi_env env) -{ - napi_value encodingFormat = nullptr; - napi_create_object(env, &encodingFormat); - - AddUint32Property(env, encodingFormat, "FORMAT_DER", HCF_FORMAT_DER); - AddUint32Property(env, encodingFormat, "FORMAT_PEM", HCF_FORMAT_PEM); - - return encodingFormat; -} - -static void DefineEncodingFormatProperties(napi_env env, napi_value exports) -{ - napi_property_descriptor desc[] = { - DECLARE_NAPI_PROPERTY("EncodingFormat", CreateEncodingFormat(env)), - }; - napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); -} - static napi_value CreateCryptoMode(napi_env env) { napi_value cryptoMode = nullptr; @@ -85,15 +61,8 @@ static napi_value CreateResultCode(napi_env env) AddUint32Property(env, resultCode, "INVALID_PARAMS", JS_ERR_INVALID_PARAMS); AddUint32Property(env, resultCode, "NOT_SUPPORT", JS_ERR_NOT_SUPPORT); AddUint32Property(env, resultCode, "ERR_OUT_OF_MEMORY", JS_ERR_OUT_OF_MEMORY); - AddUint32Property(env, resultCode, "ERR_INTERNAL_ERROR", JS_ERR_INTERNAL_ERROR); + AddUint32Property(env, resultCode, "ERR_RUNTIME_ERROR", JS_ERR_RUNTIME_ERROR); AddUint32Property(env, resultCode, "ERR_CRYPTO_OPERATION", JS_ERR_CRYPTO_OPERATION); - AddUint32Property(env, resultCode, "ERR_CERT_SIGNATURE_FAILURE", JS_ERR_CERT_SIGNATURE_FAILURE); - AddUint32Property(env, resultCode, "ERR_CERT_NOT_YET_VALID", JS_ERR_CERT_NOT_YET_VALID); - AddUint32Property(env, resultCode, "ERR_CERT_HAS_EXPIRED", JS_ERR_CERT_HAS_EXPIRED); - AddUint32Property(env, resultCode, "ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY", - JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY); - AddUint32Property(env, resultCode, "ERR_KEYUSAGE_NO_CERTSIGN", JS_ERR_KEYUSAGE_NO_CERTSIGN); - AddUint32Property(env, resultCode, "ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE", JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE); return resultCode; } @@ -113,7 +82,6 @@ static napi_value ModuleExport(napi_env env, napi_value exports) { LOGI("module init start."); - DefineEncodingFormatProperties(env, exports); DefineCryptoModeProperties(env, exports); DefineResultCodeProperties(env, exports); NapiAsyKeyGenerator::DefineAsyKeyGeneratorJSClass(env, exports); @@ -124,35 +92,28 @@ static napi_value ModuleExport(napi_env env, napi_value exports) NapiSign::DefineSignJSClass(env, exports); NapiVerify::DefineVerifyJSClass(env, exports); NapiKeyAgreement::DefineKeyAgreementJSClass(env, exports); - // NapiCertFactory::DefineCertFactoryJSClass(env, exports); - NapiCertChainValidator::DefineCertChainValidatorJSClass(env, exports); NapiMac::DefineMacJSClass(env, exports); NapiMd::DefineMdJSClass(env, exports); - NapiPubKey::DefinePubKeyJSClass(env); NapiRand::DefineRandJSClass(env, exports); NapiSymKeyGenerator::DefineSymKeyGeneratorJSClass(env, exports); NapiCipher::DefineCipherJSClass(env, exports); NapiSymKey::DefineSymKeyJSClass(env); NapiKey::DefineHcfKeyJSClass(env); - NapiX509Certificate::DefineX509CertJSClass(env, exports); - NapiX509CrlEntry::DefineX509CrlEntryJSClass(env); - NapiX509Crl::DefineX509CrlJSClass(env, exports); LOGI("module init end."); return exports; } -static napi_module cryptoFrameworkModule = { - .nm_version = 1, - .nm_flags = 0, - .nm_filename = nullptr, - .nm_register_func = ModuleExport, - .nm_modname = "security.cryptoFramework", - .nm_priv = ((void*)0), - .reserved = { 0 }, -}; - extern "C" __attribute__((constructor)) void RegisterModule(void) { + static napi_module cryptoFrameworkModule = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = ModuleExport, + .nm_modname = "security.cryptoFramework", + .nm_priv = nullptr, + .reserved = { nullptr }, + }; napi_module_register(&cryptoFrameworkModule); } } // namespace CryptoFramework diff --git a/frameworks/js/napi/src/napi_key.cpp b/frameworks/js/napi/crypto/src/napi_key.cpp similarity index 73% rename from frameworks/js/napi/src/napi_key.cpp rename to frameworks/js/napi/crypto/src/napi_key.cpp index 832f4b3c8613ee0529d107d8aa70d5d3fc52e57a..dcbe772022b2b096c3cd9bd4621d1702a3d3aca8 100644 --- a/frameworks/js/napi/src/napi_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_key.cpp @@ -17,7 +17,6 @@ #include "securec.h" #include "log.h" -#include "memory.h" #include "napi_utils.h" #include "napi_crypto_framework_defines.h" @@ -30,12 +29,9 @@ NapiKey::NapiKey(HcfKey *hcfKey) this->hcfKey_ = hcfKey; } -NapiKey::~NapiKey() -{ - OH_HCF_OBJ_DESTROY(this->hcfKey_); -} +NapiKey::~NapiKey() {} -HcfKey *NapiKey::GetHcfKey() +HcfKey *NapiKey::GetHcfKey() const { return this->hcfKey_; } @@ -44,14 +40,14 @@ napi_value NapiKey::JsGetAlgorithm(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; NapiKey *napiKey = nullptr; - napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - (void)napi_unwrap(env, thisVar, (void **)&napiKey); + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); HcfKey *key = napiKey->GetHcfKey(); const char *algo = key->getAlgorithm(key); napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)algo, NAPI_AUTO_LENGTH, &instance); + napi_create_string_utf8(env, algo, NAPI_AUTO_LENGTH, &instance); return instance; } @@ -59,14 +55,14 @@ napi_value NapiKey::JsGetFormat(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; NapiKey *napiKey = nullptr; - napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - (void)napi_unwrap(env, thisVar, (void **)&napiKey); + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); HcfKey *key = napiKey->GetHcfKey(); const char *format = key->getFormat(key); napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)format, NAPI_AUTO_LENGTH, &instance); + napi_create_string_utf8(env, format, NAPI_AUTO_LENGTH, &instance); return instance; } @@ -74,19 +70,20 @@ napi_value NapiKey::JsGetEncoded(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; NapiKey *napiKey = nullptr; - napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - (void)napi_unwrap(env, thisVar, (void **)&napiKey); + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiKey))); HcfKey *key = napiKey->GetHcfKey(); - HcfBlob blob = {0}; + HcfBlob blob = { .data = nullptr, .len = 0 }; HcfResult res = key->getEncoded(key, &blob); if (res != 0) { + napi_throw(env, GenerateBusinessError(env, res, "getEncoded failed.")); LOGE("getEncoded failed!"); return nullptr; } napi_value instance = ConvertBlobToNapiValue(env, &blob); - HcfFree(blob.data); + HcfBlobDataFree(&blob); return instance; } @@ -97,15 +94,6 @@ napi_value NapiKey::KeyConstructor(napi_env env, napi_callback_info info) return thisVar; } -napi_value NapiKey::CreateHcfKey(napi_env env) -{ - napi_value instance; - napi_value constructor = nullptr; - napi_get_reference_value(env, classRef_, &constructor); - napi_new_instance(env, constructor, 0, nullptr, &instance); - return instance; -} - void NapiKey::DefineHcfKeyJSClass(napi_env env) { napi_property_descriptor classDesc[] = { diff --git a/frameworks/js/napi/src/napi_key_agreement.cpp b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp similarity index 90% rename from frameworks/js/napi/src/napi_key_agreement.cpp rename to frameworks/js/napi/crypto/src/napi_key_agreement.cpp index 85a3c15576e9f021b4ff1f7f94a928deb9f3777f..7fb23eb54669e440dd2b0797e08e12b71bf27072 100644 --- a/frameworks/js/napi/src/napi_key_agreement.cpp +++ b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp @@ -74,7 +74,7 @@ static bool BuildKeyAgreementJsCtx(napi_env env, napi_callback_info info, KeyAgr { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_THREE; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_THREE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { @@ -84,8 +84,8 @@ static bool BuildKeyAgreementJsCtx(napi_env env, napi_callback_info info, KeyAgr } ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiKeyAgreement *napiKeyAgreement = NULL; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiKeyAgreement)); + NapiKeyAgreement *napiKeyAgreement = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiKeyAgreement)); if (status != napi_ok) { LOGE("failed to unwrap napi verify obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -93,8 +93,8 @@ static bool BuildKeyAgreementJsCtx(napi_env env, napi_callback_info info, KeyAgr } size_t index = 0; - NapiPriKey *napiPriKey = NULL; - status = napi_unwrap(env, argv[index], (void **)(&napiPriKey)); + NapiPriKey *napiPriKey = nullptr; + status = napi_unwrap(env, argv[index], reinterpret_cast(&napiPriKey)); if (status != napi_ok) { LOGE("failed to unwrap priKey verify obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PriKey]: param unwarp error.")); @@ -102,8 +102,8 @@ static bool BuildKeyAgreementJsCtx(napi_env env, napi_callback_info info, KeyAgr } index++; - NapiPubKey *napiPubKey = NULL; - status = napi_unwrap(env, argv[index], (void **)(&napiPubKey)); + NapiPubKey *napiPubKey = nullptr; + status = napi_unwrap(env, argv[index], reinterpret_cast(&napiPubKey)); if (status != napi_ok) { LOGE("failed to unwrap napi pubKey obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PubKey]: param unwarp error.")); @@ -145,7 +145,8 @@ static void ReturnPromiseResult(napi_env env, KeyAgreementCtx *ctx, napi_value r if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, + GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); } } @@ -194,7 +195,7 @@ static napi_value NewKeyAgreementAsyncWork(napi_env env, KeyAgreementCtx *ctx) KeyAgreementAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -214,7 +215,7 @@ NapiKeyAgreement::NapiKeyAgreement(HcfKeyAgreement *keyAgreement) NapiKeyAgreement::~NapiKeyAgreement() { - OH_HCF_OBJ_DESTROY(this->keyAgreement_); + HcfObjDestroy(this->keyAgreement_); } HcfKeyAgreement *NapiKeyAgreement::GetKeyAgreement() @@ -225,10 +226,10 @@ HcfKeyAgreement *NapiKeyAgreement::GetKeyAgreement() napi_value NapiKeyAgreement::JsGenerateSecret(napi_env env, napi_callback_info info) { LOGI("enter ..."); - KeyAgreementCtx *ctx = (KeyAgreementCtx *)HcfMalloc(sizeof(KeyAgreementCtx), 0); - if (ctx == NULL) { + KeyAgreementCtx *ctx = static_cast(HcfMalloc(sizeof(KeyAgreementCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildKeyAgreementJsCtx(env, info, ctx)) { @@ -254,12 +255,12 @@ napi_value NapiKeyAgreement::KeyAgreementConstructor(napi_env env, napi_callback napi_value NapiKeyAgreement::CreateJsKeyAgreement(napi_env env, napi_callback_info info) { LOGI("enter ..."); - size_t exceptedArgc = PARAMS_NUM_ONE; - size_t argc; + size_t expectedArgc = PARAMS_NUM_ONE; + size_t argc = PARAMS_NUM_ONE; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return nullptr; } @@ -274,7 +275,7 @@ napi_value NapiKeyAgreement::CreateJsKeyAgreement(napi_env env, napi_callback_in return nullptr; } - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate(algName.c_str(), &keyAgreement); if (res != HCF_SUCCESS) { LOGE("create c keyAgreement fail."); diff --git a/frameworks/js/napi/src/napi_key_pair.cpp b/frameworks/js/napi/crypto/src/napi_key_pair.cpp similarity index 62% rename from frameworks/js/napi/src/napi_key_pair.cpp rename to frameworks/js/napi/crypto/src/napi_key_pair.cpp index b20b4fe04bb6e6be248cdc45dc1507520341024e..a2fb45b1a8a6cada66f6e854253ad30dd11918ae 100644 --- a/frameworks/js/napi/src/napi_key_pair.cpp +++ b/frameworks/js/napi/crypto/src/napi_key_pair.cpp @@ -21,8 +21,6 @@ #include "napi_pri_key.h" #include "napi_pub_key.h" -#include "napi_utils.h" - namespace OHOS { namespace CryptoFramework { thread_local napi_ref NapiKeyPair::classRef_ = nullptr; @@ -34,7 +32,8 @@ NapiKeyPair::NapiKeyPair(HcfKeyPair *keyPair) NapiKeyPair::~NapiKeyPair() { - OH_HCF_OBJ_DESTROY(this->keyPair_); + HcfObjDestroy(this->keyPair_); + this->keyPair_ = nullptr; } napi_value NapiKeyPair::KeyPairConstructor(napi_env env, napi_callback_info info) @@ -55,31 +54,33 @@ napi_value NapiKeyPair::ConvertToJsKeyPair(napi_env env) napi_get_reference_value(env, classRef_, &constructor); napi_new_instance(env, constructor, 0, nullptr, &instance); - NapiPubKey *napiPubKey = new NapiPubKey(this->keyPair_->pubKey); - NapiPriKey *napiPriKey = new NapiPriKey(this->keyPair_->priKey); - - napi_value pubKey = napiPubKey->ConvertToJsPubKey(env); - napi_value priKey = napiPriKey->ConvertToJsPriKey(env); - - napi_wrap( - env, pubKey, napiPubKey, - [](napi_env env, void *data, void *hint) { - NapiPubKey *napiPubKey = static_cast(data); - delete napiPubKey; - return; - }, - nullptr, nullptr); - napi_wrap( - env, priKey, napiPriKey, - [](napi_env env, void *data, void *hint) { - NapiPriKey *napiPriKey = static_cast(data); - delete napiPriKey; - return; - }, - nullptr, nullptr); + if (this->keyPair_->pubKey != nullptr) { + NapiPubKey *napiPubKey = new NapiPubKey(this->keyPair_->pubKey); + napi_value pubKey = napiPubKey->ConvertToJsPubKey(env); + napi_wrap( + env, pubKey, napiPubKey, + [](napi_env env, void *data, void *hint) { + NapiPubKey *napiPubKey = static_cast(data); + delete napiPubKey; + return; + }, + nullptr, nullptr); + napi_set_named_property(env, instance, CRYPTO_TAG_PUB_KEY.c_str(), pubKey); + } - napi_set_named_property(env, instance, CRYPTO_TAG_PUB_KEY.c_str(), pubKey); - napi_set_named_property(env, instance, CRYPTO_TAG_PRI_KEY.c_str(), priKey); + if (this->keyPair_->priKey != nullptr) { + NapiPriKey *napiPriKey = new NapiPriKey(this->keyPair_->priKey); + napi_value priKey = napiPriKey->ConvertToJsPriKey(env); + napi_wrap( + env, priKey, napiPriKey, + [](napi_env env, void *data, void *hint) { + NapiPriKey *napiPriKey = static_cast(data); + delete napiPriKey; + return; + }, + nullptr, nullptr); + napi_set_named_property(env, instance, CRYPTO_TAG_PRI_KEY.c_str(), priKey); + } LOGI("out ..."); return instance; diff --git a/frameworks/js/napi/src/napi_mac.cpp b/frameworks/js/napi/crypto/src/napi_mac.cpp similarity index 91% rename from frameworks/js/napi/src/napi_mac.cpp rename to frameworks/js/napi/crypto/src/napi_mac.cpp index 41a258180d7b78a08a712384eba418c3a6d3899b..353e1f590b3dc26493070c33d721451445a0e74f 100644 --- a/frameworks/js/napi/src/napi_mac.cpp +++ b/frameworks/js/napi/crypto/src/napi_mac.cpp @@ -25,7 +25,7 @@ namespace OHOS { namespace CryptoFramework { -napi_ref NapiMac::classRef_ = nullptr; +thread_local napi_ref NapiMac::classRef_ = nullptr; struct MacCtx { napi_env env = nullptr; @@ -59,9 +59,7 @@ static void FreeCryptoFwkCtx(napi_env env, MacCtx *context) napi_delete_reference(env, context->callback); context->callback = nullptr; } - if (context->symKey != nullptr) { - OH_HCF_OBJ_DESTROY(context->symKey); - } + context->symKey = nullptr; if (context->inBlob != nullptr) { HcfFree(context->inBlob->data); context->inBlob->data = nullptr; @@ -97,7 +95,8 @@ static void ReturnPromiseResult(napi_env env, MacCtx *context, napi_value result if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + GenerateBusinessError(env, context->errCode, context->errMsg)); } } @@ -123,7 +122,7 @@ NapiMac::NapiMac(HcfMac *macObj) NapiMac::~NapiMac() { - OH_HCF_OBJ_DESTROY(this->macObj_); + HcfObjDestroy(this->macObj_); } static void MacInitExecute(napi_env env, void *data) @@ -132,7 +131,7 @@ static void MacInitExecute(napi_env env, void *data) MacCtx *context = static_cast(data); NapiMac *macClass = context->macClass; HcfMac *macObj = macClass->GetMac(); - HcfSymKey *symKey = (HcfSymKey *)context->symKey; + HcfSymKey *symKey = context->symKey; context->errCode = macObj->init(macObj, symKey); if (context->errCode != HCF_SUCCESS) { LOGE("init failed!"); @@ -158,7 +157,7 @@ static void MacUpdateExecute(napi_env env, void *data) MacCtx *context = static_cast(data); NapiMac *macClass = context->macClass; HcfMac *macObj = macClass->GetMac(); - HcfBlob *inBlob = static_cast(context->inBlob); + HcfBlob *inBlob = reinterpret_cast(context->inBlob); context->errCode = macObj->update(macObj, inBlob); if (context->errCode != HCF_SUCCESS) { LOGE("update failed!"); @@ -184,7 +183,7 @@ static void MacDoFinalExecute(napi_env env, void *data) MacCtx *context = static_cast(data); NapiMac *macClass = context->macClass; HcfMac *macObj = macClass->GetMac(); - HcfBlob *outBlob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *outBlob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (outBlob == nullptr) { LOGE("outBlob is null!"); context->errCode = HCF_ERR_MALLOC; @@ -221,13 +220,13 @@ napi_value NapiMac::MacInit(napi_env env, napi_callback_info info) { size_t expectedArgsCount = ARGS_SIZE_TWO; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } - MacCtx *context = (MacCtx *)HcfMalloc(sizeof(MacCtx), 0); + MacCtx *context = static_cast(HcfMalloc(sizeof(MacCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -235,7 +234,7 @@ napi_value NapiMac::MacInit(napi_env env, napi_callback_info info) } context->macClass = this; NapiSymKey *symKey = nullptr; - napi_unwrap(env, argv[PARAM0], (void**)&symKey); + napi_unwrap(env, argv[PARAM0], reinterpret_cast(&symKey)); if (symKey == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "symKey is null")); LOGE("symKey is null!"); @@ -252,7 +251,7 @@ napi_value NapiMac::MacInit(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "Init"), MacInitExecute, MacInitComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -266,13 +265,13 @@ napi_value NapiMac::MacUpdate(napi_env env, napi_callback_info info) { size_t expectedArgsCount = ARGS_SIZE_TWO; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } - MacCtx *context = (MacCtx *)HcfMalloc(sizeof(MacCtx), 0); + MacCtx *context = static_cast(HcfMalloc(sizeof(MacCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -293,7 +292,7 @@ napi_value NapiMac::MacUpdate(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "MacUpate"), MacUpdateExecute, MacUpdateComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -307,13 +306,13 @@ napi_value NapiMac::MacDoFinal(napi_env env, napi_callback_info info) { size_t expectedArgsCount = ARGS_SIZE_ONE; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } - MacCtx *context = (MacCtx *)HcfMalloc(sizeof(MacCtx), 0); + MacCtx *context = static_cast(HcfMalloc(sizeof(MacCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -329,7 +328,7 @@ napi_value NapiMac::MacDoFinal(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "MacDoFinal"), MacDoFinalExecute, MacDoFinalComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -341,13 +340,6 @@ napi_value NapiMac::MacDoFinal(napi_env env, napi_callback_info info) napi_value NapiMac::GetMacLength(napi_env env, napi_callback_info info) { - size_t expectedArgsCount = ARGS_SIZE_ZERO; - size_t argc = expectedArgsCount; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } HcfMac *macObj = GetMac(); uint32_t retLen = macObj->getMacLength(macObj); napi_value napiLen = nullptr; @@ -416,11 +408,11 @@ napi_value NapiMac::MacConstructor(napi_env env, napi_callback_info info) napi_value NapiMac::CreateMac(napi_env env, napi_callback_info info) { - size_t exceptedArgc = ARGS_SIZE_ONE; - size_t argc; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + size_t expectedArgc = ARGS_SIZE_ONE; + size_t argc = expectedArgc; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return nullptr; } @@ -451,7 +443,7 @@ napi_value NapiMac::CreateMac(napi_env env, napi_callback_info info) napi_wrap( env, instance, macNapiObj, [](napi_env env, void *data, void *hint) { - NapiMac *mac = (NapiMac *)(data); + NapiMac *mac = static_cast(data); delete mac; return; }, diff --git a/frameworks/js/napi/src/napi_md.cpp b/frameworks/js/napi/crypto/src/napi_md.cpp similarity index 91% rename from frameworks/js/napi/src/napi_md.cpp rename to frameworks/js/napi/crypto/src/napi_md.cpp index 4c84f6d3689142f4e136b5fde6a84b0073594e87..1416a703a934f3839dc0b1224d4fd57d7602408a 100644 --- a/frameworks/js/napi/src/napi_md.cpp +++ b/frameworks/js/napi/crypto/src/napi_md.cpp @@ -24,7 +24,7 @@ namespace OHOS { namespace CryptoFramework { -napi_ref NapiMd::classRef_ = nullptr; +thread_local napi_ref NapiMd::classRef_ = nullptr; struct MdCtx { napi_env env = nullptr; @@ -73,7 +73,10 @@ static void FreeCryptoFwkCtx(napi_env env, MdCtx *context) static void ReturnCallbackResult(napi_env env, MdCtx *context, napi_value result) { - napi_value businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + napi_value businessError = nullptr; + if (context->errCode != HCF_SUCCESS) { + businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; napi_value func = nullptr; napi_get_reference_value(env, context->callback, &func); @@ -89,7 +92,8 @@ static void ReturnPromiseResult(napi_env env, MdCtx *context, napi_value result) if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + GenerateBusinessError(env, context->errCode, context->errMsg)); } } @@ -115,7 +119,7 @@ NapiMd::NapiMd(HcfMd *mdObj) NapiMd::~NapiMd() { - OH_HCF_OBJ_DESTROY(this->mdObj_); + HcfObjDestroy(this->mdObj_); } static void MdUpdateExecute(napi_env env, void *data) @@ -148,7 +152,7 @@ static void MdDoFinalExecute(napi_env env, void *data) MdCtx *context = static_cast(data); NapiMd *mdClass = context->mdClass; HcfMd *mdObj = mdClass->GetMd(); - HcfBlob *outBlob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *outBlob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (outBlob == nullptr) { LOGE("outBlob is null!"); context->errCode = HCF_ERR_MALLOC; @@ -184,13 +188,13 @@ napi_value NapiMd::MdUpdate(napi_env env, napi_callback_info info) { // check param count size_t argc = ARGS_SIZE_TWO; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (!CheckArgsCount(env, argc, ARGS_SIZE_TWO, false)) { return nullptr; } - MdCtx *context = (MdCtx *)HcfMalloc(sizeof(MdCtx), 0); + MdCtx *context = static_cast(HcfMalloc(sizeof(MdCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -211,7 +215,7 @@ napi_value NapiMd::MdUpdate(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "MdUpdate"), MdUpdateExecute, MdUpdateComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -225,13 +229,13 @@ napi_value NapiMd::MdDoFinal(napi_env env, napi_callback_info info) { size_t expectedArgsCount = ARGS_SIZE_ONE; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false)) { return nullptr; } - MdCtx *context = (MdCtx *)HcfMalloc(sizeof(MdCtx), 0); + MdCtx *context = static_cast(HcfMalloc(sizeof(MdCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -246,7 +250,7 @@ napi_value NapiMd::MdDoFinal(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "MdDoFinal"), MdDoFinalExecute, MdDoFinalComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -258,13 +262,6 @@ napi_value NapiMd::MdDoFinal(napi_env env, napi_callback_info info) napi_value NapiMd::GetMdLength(napi_env env, napi_callback_info info) { - size_t expectedArgsCount = ARGS_SIZE_ZERO; - size_t argc = expectedArgsCount; - napi_value thisVar = nullptr; - napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr); - if (!CheckArgsCount(env, argc, ARGS_SIZE_ZERO, true)) { - return nullptr; - } HcfMd *mdObj = GetMd(); uint32_t retLen = mdObj->getMdLength(mdObj); napi_value napiLen = nullptr; @@ -323,11 +320,11 @@ napi_value NapiMd::MdConstructor(napi_env env, napi_callback_info info) napi_value NapiMd::CreateMd(napi_env env, napi_callback_info info) { - size_t exceptedArgc = ARGS_SIZE_ONE; - size_t argc; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + size_t expectedArgc = ARGS_SIZE_ONE; + size_t argc = expectedArgc; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return nullptr; } @@ -358,7 +355,7 @@ napi_value NapiMd::CreateMd(napi_env env, napi_callback_info info) napi_wrap( env, instance, mdNapiObj, [](napi_env env, void *data, void *hint) { - NapiMd *md = (NapiMd *)(data); + NapiMd *md = static_cast(data); delete md; return; }, diff --git a/frameworks/js/napi/src/napi_pri_key.cpp b/frameworks/js/napi/crypto/src/napi_pri_key.cpp similarity index 86% rename from frameworks/js/napi/src/napi_pri_key.cpp rename to frameworks/js/napi/crypto/src/napi_pri_key.cpp index 8d13c7eb2099ebaf86e7fea1a4bb15cdb477e04d..9014e155c3b826d2fb8da53bdb099994f84a84fc 100644 --- a/frameworks/js/napi/src/napi_pri_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pri_key.cpp @@ -16,7 +16,6 @@ #include "napi_pri_key.h" #include "log.h" -#include "memory.h" #include "napi_crypto_framework_defines.h" #include "napi_utils.h" #include "securec.h" @@ -25,16 +24,13 @@ namespace OHOS { namespace CryptoFramework { thread_local napi_ref NapiPriKey::classRef_ = nullptr; -NapiPriKey::NapiPriKey(HcfPriKey *priKey) -{ - this->priKey_ = priKey; -} +NapiPriKey::NapiPriKey(HcfPriKey *priKey) : NapiKey(reinterpret_cast(priKey)) {} NapiPriKey::~NapiPriKey() {} HcfPriKey *NapiPriKey::GetPriKey() { - return this->priKey_; + return reinterpret_cast(NapiKey::GetHcfKey()); } napi_value NapiPriKey::PriKeyConstructor(napi_env env, napi_callback_info info) @@ -57,8 +53,8 @@ napi_value NapiPriKey::ConvertToJsPriKey(napi_env env) napi_get_reference_value(env, classRef_, &constructor); napi_new_instance(env, constructor, 0, nullptr, &instance); - const char *algName = this->priKey_->base.getAlgorithm(&(this->priKey_->base)); - const char *format = this->priKey_->base.getFormat(&(this->priKey_->base)); + const char *algName = this->GetPriKey()->base.getAlgorithm(&(this->GetPriKey()->base)); + const char *format = this->GetPriKey()->base.getFormat(&(this->GetPriKey()->base)); napi_value napiAlgName = nullptr; napi_create_string_utf8(env, algName, NAPI_AUTO_LENGTH, &napiAlgName); @@ -77,7 +73,7 @@ napi_value NapiPriKey::JsGetEncoded(napi_env env, napi_callback_info info) napi_value thisVar = nullptr; napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); NapiPriKey *napiPriKey = nullptr; - napi_unwrap(env, thisVar, (void **)(&napiPriKey)); + napi_unwrap(env, thisVar, reinterpret_cast(&napiPriKey)); HcfPriKey *priKey = napiPriKey->GetPriKey(); @@ -89,7 +85,7 @@ napi_value NapiPriKey::JsGetEncoded(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); - HcfFree(returnBlob.data); + HcfBlobDataFree(&returnBlob); return instance; } @@ -98,7 +94,7 @@ napi_value NapiPriKey::JsClearMem(napi_env env, napi_callback_info info) napi_value thisVar = nullptr; napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); NapiPriKey *napiPriKey = nullptr; - napi_unwrap(env, thisVar, (void **)(&napiPriKey)); + napi_unwrap(env, thisVar, reinterpret_cast(&napiPriKey)); HcfPriKey *priKey = napiPriKey->GetPriKey(); diff --git a/frameworks/js/napi/src/napi_pub_key.cpp b/frameworks/js/napi/crypto/src/napi_pub_key.cpp similarity index 86% rename from frameworks/js/napi/src/napi_pub_key.cpp rename to frameworks/js/napi/crypto/src/napi_pub_key.cpp index 6e91f71fbf1c9163cbcb613b7980e86abb7c3b89..ac5ce9ac314c5dae2c66216d6d98040ce2532d85 100644 --- a/frameworks/js/napi/src/napi_pub_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pub_key.cpp @@ -16,7 +16,6 @@ #include "napi_pub_key.h" #include "log.h" -#include "memory.h" #include "napi_crypto_framework_defines.h" #include "napi_utils.h" #include "securec.h" @@ -25,16 +24,13 @@ namespace OHOS { namespace CryptoFramework { thread_local napi_ref NapiPubKey::classRef_ = nullptr; -NapiPubKey::NapiPubKey(HcfPubKey *pubKey) -{ - this->pubKey_ = pubKey; -} +NapiPubKey::NapiPubKey(HcfPubKey *pubKey) : NapiKey(reinterpret_cast(pubKey)) {} NapiPubKey::~NapiPubKey() {} HcfPubKey *NapiPubKey::GetPubKey() { - return this->pubKey_; + return reinterpret_cast(NapiKey::GetHcfKey()); } napi_value NapiPubKey::PubKeyConstructor(napi_env env, napi_callback_info info) @@ -57,8 +53,8 @@ napi_value NapiPubKey::ConvertToJsPubKey(napi_env env) napi_get_reference_value(env, classRef_, &constructor); napi_new_instance(env, constructor, 0, nullptr, &instance); - const char *algName = this->pubKey_->base.getAlgorithm(&(this->pubKey_->base)); - const char *format = this->pubKey_->base.getFormat(&(this->pubKey_->base)); + const char *algName = this->GetPubKey()->base.getAlgorithm(&(this->GetPubKey()->base)); + const char *format = this->GetPubKey()->base.getFormat(&(this->GetPubKey()->base)); napi_value napiAlgName = nullptr; napi_create_string_utf8(env, algName, NAPI_AUTO_LENGTH, &napiAlgName); @@ -77,7 +73,7 @@ napi_value NapiPubKey::JsGetEncoded(napi_env env, napi_callback_info info) napi_value thisVar = nullptr; napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); NapiPubKey *napiPubKey = nullptr; - napi_unwrap(env, thisVar, (void **)(&napiPubKey)); + napi_unwrap(env, thisVar, reinterpret_cast(&napiPubKey)); HcfPubKey *pubKey = napiPubKey->GetPubKey(); HcfBlob returnBlob; @@ -88,7 +84,7 @@ napi_value NapiPubKey::JsGetEncoded(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); - HcfFree(returnBlob.data); + HcfBlobDataFree(&returnBlob); return instance; } diff --git a/frameworks/js/napi/src/napi_rand.cpp b/frameworks/js/napi/crypto/src/napi_rand.cpp similarity index 75% rename from frameworks/js/napi/src/napi_rand.cpp rename to frameworks/js/napi/crypto/src/napi_rand.cpp index aa16244c37a1379b0d349007c00446ae7cf767b0..e20aa98e197f607d4c513df7b72bf175b03e8d61 100644 --- a/frameworks/js/napi/src/napi_rand.cpp +++ b/frameworks/js/napi/crypto/src/napi_rand.cpp @@ -24,7 +24,7 @@ namespace OHOS { namespace CryptoFramework { -napi_ref NapiRand::classRef_ = nullptr; +thread_local napi_ref NapiRand::classRef_ = nullptr; struct RandCtx { napi_env env = nullptr; @@ -73,8 +73,10 @@ static void FreeCryptoFwkCtx(napi_env env, RandCtx *context) static void ReturnCallbackResult(napi_env env, RandCtx *context, napi_value result) { - napi_value businessError = GenerateBusinessError(env, context->errCode, context->errMsg); - + napi_value businessError = nullptr; + if (context->errCode != HCF_SUCCESS) { + businessError = GenerateBusinessError(env, context->errCode, context->errMsg); + } napi_value params[ARGS_SIZE_TWO] = { businessError, result }; napi_value func = nullptr; @@ -91,7 +93,8 @@ static void ReturnPromiseResult(napi_env env, RandCtx *context, napi_value resul if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + GenerateBusinessError(env, context->errCode, context->errMsg)); } } @@ -117,7 +120,7 @@ NapiRand::NapiRand(HcfRand *randObj) NapiRand::~NapiRand() { - OH_HCF_OBJ_DESTROY(this->randObj_); + HcfObjDestroy(this->randObj_); } static void GenerateRandomExecute(napi_env env, void *data) @@ -125,7 +128,7 @@ static void GenerateRandomExecute(napi_env env, void *data) RandCtx *context = static_cast(data); NapiRand *randClass = context->randClass; HcfRand *randObj = randClass->GetRand(); - HcfBlob *randBlob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); + HcfBlob *randBlob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); if (randBlob == nullptr) { LOGE("randBlob is null!"); context->errCode = HCF_ERR_MALLOC; @@ -158,39 +161,11 @@ static void GenerateRandomComplete(napi_env env, napi_status status, void *data) FreeCryptoFwkCtx(env, context); } -static void SetSeedExecute(napi_env env, void *data) -{ - RandCtx *context = static_cast(data); - NapiRand *randClass = context->randClass; - HcfRand *randObj = randClass->GetRand(); - HcfBlob *seedBlob = static_cast(context->seedBlob); - context->errCode = randObj->setSeed(randObj, seedBlob); - if (context->errCode != HCF_SUCCESS) { - LOGE("setSeed failed!"); - context->errMsg = "setSeed failed"; - return; - } -} - -static void SetSeedComplete(napi_env env, napi_status status, void *data) -{ - LOGI("enter SetSeedComplete ..."); - RandCtx *context = static_cast(data); - napi_value nullInstance = nullptr; - napi_get_null(env, &nullInstance); - if (context->asyncType == ASYNC_TYPE_CALLBACK) { - ReturnCallbackResult(env, context, nullInstance); - } else { - ReturnPromiseResult(env, context, nullInstance); - } - FreeCryptoFwkCtx(env, context); -} - napi_value NapiRand::GenerateRandom(napi_env env, napi_callback_info info) { size_t expectedArgsCount = ARGS_SIZE_TWO; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_value thisVar = nullptr; napi_value ret = NapiGetNull(env); napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); @@ -199,7 +174,7 @@ napi_value NapiRand::GenerateRandom(napi_env env, napi_callback_info info) LOGE("The arguments count is not expected!"); return ret; } - RandCtx *context = (RandCtx *)HcfMalloc(sizeof(RandCtx), 0); + RandCtx *context = static_cast(HcfMalloc(sizeof(RandCtx), 0)); if (context == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); LOGE("malloc context failed!"); @@ -219,7 +194,7 @@ napi_value NapiRand::GenerateRandom(napi_env env, napi_callback_info info) env, nullptr, GetResourceName(env, "GenerateRandom"), GenerateRandomExecute, GenerateRandomComplete, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); if (context->asyncType == ASYNC_TYPE_PROMISE) { @@ -231,46 +206,24 @@ napi_value NapiRand::GenerateRandom(napi_env env, napi_callback_info info) napi_value NapiRand::SetSeed(napi_env env, napi_callback_info info) { - size_t expectedArgsCount = ARGS_SIZE_TWO; + size_t expectedArgsCount = ARGS_SIZE_ONE; size_t argc = expectedArgsCount; - napi_value argv[ARGS_SIZE_TWO] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_value thisVar = nullptr; - napi_value ret = NapiGetNull(env); napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); - if ((argc != expectedArgsCount) && (argc != expectedArgsCount - CALLBACK_SIZE)) { + if (argc != expectedArgsCount) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "invalid params count")); LOGE("The arguments count is not expected!"); - return ret; - } - RandCtx *context = (RandCtx *)HcfMalloc(sizeof(RandCtx), 0); - if (context == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc context failed")); - LOGE("malloc context failed!"); - return ret; - } - context->randClass = this; - context->randBlob = GetBlobFromNapiValue(env, argv[PARAM0]); - if (context->randBlob == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "randBlob is null")); - LOGE("randBlob is null!"); - return ret; - } - if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_TWO, argv[PARAM1])) { - FreeCryptoFwkCtx(env, context); return nullptr; } - napi_create_async_work( - env, nullptr, GetResourceName(env, "SetSeed"), - SetSeedExecute, - SetSeedComplete, - (void *)context, - &context->asyncWork); - napi_queue_async_work(env, context->asyncWork); - if (context->asyncType == ASYNC_TYPE_PROMISE) { - return context->promise; - } else { - return NapiGetNull(env); + HcfBlob *seedBlob = GetBlobFromNapiValue(env, argv[PARAM0]); + HcfRand *randObj = GetRand(); + HcfResult res = randObj->setSeed(randObj, seedBlob); + if (res != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, res, "set seed failed.")); + LOGE("set seed failed."); } + return nullptr; } static napi_value NapiGenerateRandom(napi_env env, napi_callback_info info) @@ -296,7 +249,7 @@ static napi_value NapiSetSeed(napi_env env, napi_callback_info info) napi_unwrap(env, thisVar, reinterpret_cast(&randObj)); if (randObj == nullptr) { LOGE("randObj is nullptr!"); - return NapiGetNull(env); + return nullptr; } return randObj->SetSeed(env, info); } @@ -310,13 +263,6 @@ napi_value NapiRand::RandConstructor(napi_env env, napi_callback_info info) napi_value NapiRand::CreateRand(napi_env env, napi_callback_info info) { - size_t exceptedArgc = ARGS_SIZE_ZERO; - size_t argc; - napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr); - if (argc != exceptedArgc) { - LOGE("The input args num is invalid."); - return nullptr; - } HcfRand *randObj = nullptr; HcfResult res = HcfRandCreate(&randObj); if (res != HCF_SUCCESS) { @@ -327,7 +273,7 @@ napi_value NapiRand::CreateRand(napi_env env, napi_callback_info info) napi_value instance = nullptr; napi_value constructor = nullptr; napi_get_reference_value(env, classRef_, &constructor); - napi_new_instance(env, constructor, argc, nullptr, &instance); + napi_new_instance(env, constructor, 0, nullptr, &instance); NapiRand *randNapiObj = new (std::nothrow) NapiRand(randObj); if (randNapiObj == nullptr) { LOGE("create napi obj failed"); @@ -336,7 +282,7 @@ napi_value NapiRand::CreateRand(napi_env env, napi_callback_info info) napi_wrap( env, instance, randNapiObj, [](napi_env env, void *data, void *hint) { - NapiRand *rand = (NapiRand *)(data); + NapiRand *rand = static_cast(data); delete rand; return; }, diff --git a/frameworks/js/napi/src/napi_sign.cpp b/frameworks/js/napi/crypto/src/napi_sign.cpp similarity index 91% rename from frameworks/js/napi/src/napi_sign.cpp rename to frameworks/js/napi/crypto/src/napi_sign.cpp index 94cc8acb00e064f5896b33fca2528d84b86aa281..dee597aa3a35f499ba9b6567696bc2ccb3dfb556 100644 --- a/frameworks/js/napi/src/napi_sign.cpp +++ b/frameworks/js/napi/crypto/src/napi_sign.cpp @@ -142,7 +142,7 @@ static bool BuildSignJsInitCtx(napi_env env, napi_callback_info info, SignInitCt { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { @@ -152,8 +152,8 @@ static bool BuildSignJsInitCtx(napi_env env, napi_callback_info info, SignInitCt } ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiSign *napiSign = NULL; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiSign)); + NapiSign *napiSign = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); if (status != napi_ok) { LOGE("failed to unwrap napi sign obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -161,8 +161,8 @@ static bool BuildSignJsInitCtx(napi_env env, napi_callback_info info, SignInitCt } size_t index = 0; - NapiPriKey *napiPriKey = NULL; - status = napi_unwrap(env, argv[index], (void **)(&napiPriKey)); + NapiPriKey *napiPriKey = nullptr; + status = napi_unwrap(env, argv[index], reinterpret_cast(&napiPriKey)); if (status != napi_ok) { LOGE("failed to unwrap napi priKey obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PriKey]: param unwarp error.")); @@ -185,7 +185,7 @@ static bool BuildSignJsUpdateCtx(napi_env env, napi_callback_info info, SignUpda { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { @@ -195,8 +195,8 @@ static bool BuildSignJsUpdateCtx(napi_env env, napi_callback_info info, SignUpda } ctx->asyncType = (argc == PARAMS_NUM_TWO) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiSign *napiSign = NULL; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiSign)); + NapiSign *napiSign = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); if (status != napi_ok) { LOGE("failed to unwrap napi sign obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -207,7 +207,8 @@ static bool BuildSignJsUpdateCtx(napi_env env, napi_callback_info info, SignUpda HcfBlob *blob = GetBlobFromNapiValue(env, argv[index]); if (blob == nullptr) { LOGE("failed to get data."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Data]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "[Data]: must be of the DataBlob type.")); return false; } @@ -226,7 +227,7 @@ static bool BuildSignJsDoFinalCtx(napi_env env, napi_callback_info info, SignDoF { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { @@ -237,7 +238,7 @@ static bool BuildSignJsDoFinalCtx(napi_env env, napi_callback_info info, SignDoF ctx->asyncType = (argc == PARAMS_NUM_TWO) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiSign *napiSign = nullptr; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiSign)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); if (status != napi_ok) { LOGE("failed to unwrap napi sign obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -252,7 +253,8 @@ static bool BuildSignJsDoFinalCtx(napi_env env, napi_callback_info info, SignDoF data = GetBlobFromNapiValue(env, argv[index]); if (data == nullptr) { LOGE("failed to get data."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Data]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "[Data]: must be of the DataBlob type.")); return false; } } @@ -291,7 +293,8 @@ static void ReturnInitPromiseResult(napi_env env, SignInitCtx *ctx, napi_value r if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, + COMMON_ERR_MSG.c_str())); } } @@ -318,7 +321,8 @@ static void ReturnUpdatePromiseResult(napi_env env, SignUpdateCtx *ctx, napi_val if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, + COMMON_ERR_MSG.c_str())); } } @@ -345,7 +349,8 @@ static void ReturnDoFinalPromiseResult(napi_env env, SignDoFinalCtx *ctx, napi_v if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, + COMMON_ERR_MSG.c_str())); } } @@ -441,7 +446,7 @@ static napi_value NewSignJsInitAsyncWork(napi_env env, SignInitCtx *ctx) SignJsInitAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -469,7 +474,7 @@ static napi_value NewSignJsUpdateAsyncWork(napi_env env, SignUpdateCtx *ctx) SignJsUpdateAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -497,7 +502,7 @@ static napi_value NewSignJsDoFinalAsyncWork(napi_env env, SignDoFinalCtx *ctx) SignJsDoFinalAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -517,7 +522,7 @@ NapiSign::NapiSign(HcfSign *sign) NapiSign::~NapiSign() { - OH_HCF_OBJ_DESTROY(this->sign_); + HcfObjDestroy(this->sign_); } HcfSign *NapiSign::GetSign() @@ -528,10 +533,10 @@ HcfSign *NapiSign::GetSign() napi_value NapiSign::JsInit(napi_env env, napi_callback_info info) { LOGI("enter ..."); - SignInitCtx *ctx = (SignInitCtx *)HcfMalloc(sizeof(SignInitCtx), 0); - if (ctx == NULL) { + SignInitCtx *ctx = static_cast(HcfMalloc(sizeof(SignInitCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildSignJsInitCtx(env, info, ctx)) { @@ -546,10 +551,10 @@ napi_value NapiSign::JsInit(napi_env env, napi_callback_info info) napi_value NapiSign::JsUpdate(napi_env env, napi_callback_info info) { LOGI("enter ..."); - SignUpdateCtx *ctx = (SignUpdateCtx *)HcfMalloc(sizeof(SignUpdateCtx), 0); - if (ctx == NULL) { + SignUpdateCtx *ctx = static_cast(HcfMalloc(sizeof(SignUpdateCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildSignJsUpdateCtx(env, info, ctx)) { @@ -564,10 +569,10 @@ napi_value NapiSign::JsUpdate(napi_env env, napi_callback_info info) napi_value NapiSign::JsSign(napi_env env, napi_callback_info info) { LOGI("enter ..."); - SignDoFinalCtx *ctx = (SignDoFinalCtx *)HcfMalloc(sizeof(SignDoFinalCtx), 0); - if (ctx == NULL) { + SignDoFinalCtx *ctx = static_cast(HcfMalloc(sizeof(SignDoFinalCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildSignJsDoFinalCtx(env, info, ctx)) { @@ -593,12 +598,12 @@ napi_value NapiSign::SignConstructor(napi_env env, napi_callback_info info) napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) { LOGI("enter ..."); - size_t exceptedArgc = PARAMS_NUM_ONE; - size_t argc; + size_t expectedArgc = PARAMS_NUM_ONE; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return nullptr; } @@ -613,7 +618,7 @@ napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) return nullptr; } - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate(algName.c_str(), &sign); if (res != HCF_SUCCESS) { LOGE("create c sign fail."); @@ -625,7 +630,7 @@ napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) napi_wrap( env, instance, napiSign, [](napi_env env, void *data, void *hint) { - NapiSign *napiSign = (NapiSign *)(data); + NapiSign *napiSign = static_cast(data); delete napiSign; return; }, diff --git a/frameworks/js/napi/src/napi_sym_key.cpp b/frameworks/js/napi/crypto/src/napi_sym_key.cpp similarity index 49% rename from frameworks/js/napi/src/napi_sym_key.cpp rename to frameworks/js/napi/crypto/src/napi_sym_key.cpp index ec80319687a33e1b4230b77fbb919376d8702ba2..0d2af9a7b8cd38dc79964ede5ca66caf480657cb 100644 --- a/frameworks/js/napi/src/napi_sym_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_sym_key.cpp @@ -17,7 +17,6 @@ #include "securec.h" #include "log.h" -#include "memory.h" #include "napi_utils.h" #include "napi_crypto_framework_defines.h" @@ -25,70 +24,29 @@ namespace OHOS { namespace CryptoFramework { thread_local napi_ref NapiSymKey::classRef_ = nullptr; -NapiSymKey::NapiSymKey(HcfSymKey *symKey) -{ - this->symKey_ = symKey; -} +NapiSymKey::NapiSymKey(HcfSymKey *symKey) : NapiKey(reinterpret_cast(symKey)) {} NapiSymKey::~NapiSymKey() { - OH_HCF_OBJ_DESTROY(this->symKey_); -} - -HcfSymKey *NapiSymKey::GetSymKey() -{ - return this->symKey_; -} - -napi_value NapiSymKey::JsGetAlgorithm(napi_env env, napi_callback_info info) -{ - napi_value thisVar = nullptr; - NapiSymKey *napiSymKey = nullptr; - NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - - NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&napiSymKey)); - HcfSymKey *key = napiSymKey->GetSymKey(); - - const char *algo = key->key.getAlgorithm((HcfKey *)key); - napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)algo, NAPI_AUTO_LENGTH, &instance); - return instance; + HcfObjDestroy(this->hcfKey_); + this->hcfKey_ = nullptr; } -napi_value NapiSymKey::JsGetFormat(napi_env env, napi_callback_info info) +HcfSymKey *NapiSymKey::GetSymKey() const { - napi_value thisVar = nullptr; - NapiSymKey *napiSymKey = nullptr; - NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - - NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&napiSymKey)); - HcfSymKey *key = napiSymKey->GetSymKey(); - - const char *format = key->key.getFormat((HcfKey *)key); - napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)format, NAPI_AUTO_LENGTH, &instance); - return instance; + return reinterpret_cast(NapiKey::GetHcfKey()); } -napi_value NapiSymKey::JsGetEncoded(napi_env env, napi_callback_info info) +napi_value NapiSymKey::JsClearMem(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; NapiSymKey *napiSymKey = nullptr; NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&napiSymKey)); + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiSymKey))); HcfSymKey *key = napiSymKey->GetSymKey(); - - HcfBlob blob = {0}; - HcfResult res = key->key.getEncoded((HcfKey *)key, &blob); - if (res != 0) { - napi_throw(env, GenerateBusinessError(env, res, "getEncoded failed.")); - LOGE("getEncoded failed!"); - return nullptr; - } - napi_value instance = ConvertBlobToNapiValue(env, &blob); - HcfFree(blob.data); - return instance; + key->clearMem(key); + return nullptr; } napi_value NapiSymKey::SymKeyConstructor(napi_env env, napi_callback_info info) @@ -110,9 +68,10 @@ napi_value NapiSymKey::CreateSymKey(napi_env env) void NapiSymKey::DefineSymKeyJSClass(napi_env env) { napi_property_descriptor classDesc[] = { - DECLARE_NAPI_FUNCTION("getEncoded", NapiSymKey::JsGetEncoded), - {.utf8name = "format", .getter = NapiSymKey::JsGetFormat}, - {.utf8name = "algName", .getter = NapiSymKey::JsGetAlgorithm}, + DECLARE_NAPI_FUNCTION("getEncoded", NapiKey::JsGetEncoded), + DECLARE_NAPI_FUNCTION("clearMem", NapiSymKey::JsClearMem), + {.utf8name = "format", .getter = NapiKey::JsGetFormat}, + {.utf8name = "algName", .getter = NapiKey::JsGetAlgorithm}, }; napi_value constructor = nullptr; napi_define_class(env, "SymKey", NAPI_AUTO_LENGTH, SymKeyConstructor, nullptr, diff --git a/frameworks/js/napi/src/napi_sym_key_generator.cpp b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp similarity index 86% rename from frameworks/js/napi/src/napi_sym_key_generator.cpp rename to frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp index 5897cf30a101d0d29d6f729788d5ddf51998e7da..870ace000e501f2ba679235b05d6deea0cf3d442 100644 --- a/frameworks/js/napi/src/napi_sym_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp @@ -18,7 +18,7 @@ #include "securec.h" #include "log.h" #include "memory.h" -#include "napi_key.h" +#include "napi_sym_key.h" #include "napi_utils.h" #include "napi_crypto_framework_defines.h" @@ -39,7 +39,7 @@ struct SymKeyGeneratorFwkCtxT { const char *errMsg = nullptr; HcfSymKeyGenerator *generator = nullptr; - HcfBlob keyMaterial = { 0 }; + HcfBlob keyMaterial = { .data = nullptr, .len = 0 }; }; using SymKeyGeneratorFwkCtx = SymKeyGeneratorFwkCtxT *; @@ -80,13 +80,14 @@ static bool BuildContextForGenerateKey(napi_env env, napi_callback_info info, Sy napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "generate key failed for wrong argument num.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "generate key failed for wrong argument num.")); LOGE("wrong argument num. require 0 or 1 arguments. [Argc]: %zu!", argc); return false; } context->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiSymKeyGenerator *napiGenerator; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiGenerator)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok) { LOGE("failed to unwrap NapiSymKeyGenerator obj!"); return false; @@ -101,7 +102,7 @@ static bool BuildContextForGenerateKey(napi_env env, napi_callback_info info, Sy napi_create_promise(env, &context->deferred, &context->promise); return true; } else { - return GetCallbackFromJSParams(env, argv[ARGS_SIZE_ZERO], &context->callback); + return GetCallbackFromJSParams(env, argv[0], &context->callback); } } @@ -113,14 +114,15 @@ static bool BuildContextForConvertKey(napi_env env, napi_callback_info info, Sym napi_value argv[ARGS_SIZE_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "convert key failed for wrong argument num.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "convert key failed for wrong argument num.")); LOGE("wrong argument num. require 1 or 2 arguments. [Argc]: %zu!", argc); return false; } context->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiSymKeyGenerator *napiGenerator; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiGenerator)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok) { LOGE("failed to unwrap NapiSymKeyGenerator obj!"); return false; @@ -135,7 +137,8 @@ static bool BuildContextForConvertKey(napi_env env, napi_callback_info info, Sym size_t index = 0; HcfBlob *blob = GetBlobFromNapiValue(env, argv[index++]); if (blob == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "convert key failed for invalid input blob.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "convert key failed for invalid input blob.")); LOGE("get keyMaterial failed!"); return false; } @@ -154,7 +157,8 @@ static void ReturnPromiseResult(napi_env env, SymKeyGeneratorFwkCtx context, nap if (context->errCode == HCF_SUCCESS) { napi_resolve_deferred(env, context->deferred, result); } else { - napi_reject_deferred(env, context->deferred, GenerateBusinessError(env, context->errCode, context->errMsg)); + napi_reject_deferred(env, context->deferred, + GenerateBusinessError(env, context->errCode, context->errMsg)); } } @@ -180,7 +184,7 @@ static void AsyncGenKeyProcess(napi_env env, void *data) SymKeyGeneratorFwkCtx context = static_cast(data); HcfSymKeyGenerator *generator = context->generator; - HcfSymKey *key = NULL; + HcfSymKey *key = nullptr; HcfResult res = generator->generateSymKey(generator, &key); if (res != HCF_SUCCESS) { LOGE("generate sym key failed."); @@ -195,27 +199,28 @@ static void AsyncGenKeyProcess(napi_env env, void *data) static void AsyncKeyReturn(napi_env env, napi_status status, void *data) { - napi_value instance = NapiKey::CreateHcfKey(env); + napi_value instance = NapiSymKey::CreateSymKey(env); SymKeyGeneratorFwkCtx context = static_cast(data); - NapiKey *napiKey = new (std::nothrow) NapiKey((HcfKey *)context->returnSymKey); - if (napiKey == nullptr) { - napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "new napi key failed.")); + NapiSymKey *napiSymKey = new (std::nothrow) NapiSymKey(context->returnSymKey); + if (napiSymKey == nullptr) { + napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "new napi sym key failed.")); FreeSymKeyGeneratorFwkCtx(env, context); - LOGE("new napi key failed."); + LOGE("new napi sym key failed."); return; } - napi_status ret = napi_wrap(env, instance, napiKey, + napi_status ret = napi_wrap(env, instance, napiSymKey, [](napi_env env, void *data, void *hint) { - NapiKey *napiKey = static_cast(data); - delete napiKey; + NapiSymKey *napiSymKey = static_cast(data); + delete napiSymKey; return; }, nullptr, nullptr); if (ret != napi_ok) { LOGE("failed to wrap napiSymKey obj!"); context->errCode = HCF_INVALID_PARAMS; - delete napiKey; + context->errMsg = "failed to wrap napiSymKey obj!"; + delete napiSymKey; } if (context->asyncType == ASYNC_CALLBACK) { @@ -231,7 +236,7 @@ static void AsyncConvertKeyProcess(napi_env env, void *data) SymKeyGeneratorFwkCtx context = static_cast(data); HcfSymKeyGenerator *generator = context->generator; - HcfSymKey *key = NULL; + HcfSymKey *key = nullptr; HcfResult res = generator->convertSymKey(generator, &context->keyMaterial, &key); if (res != HCF_SUCCESS) { LOGE("convertSymKey key failed!"); @@ -261,7 +266,7 @@ static napi_value NewConvertKeyAsyncWork(napi_env env, SymKeyGeneratorFwkCtx con AsyncKeyReturn(env, status, data); return; }, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); @@ -289,7 +294,7 @@ static napi_value NewGenKeyAsyncWork(napi_env env, SymKeyGeneratorFwkCtx context AsyncKeyReturn(env, status, data); return; }, - (void *)context, + static_cast(context), &context->asyncWork); napi_queue_async_work(env, context->asyncWork); @@ -307,17 +312,17 @@ NapiSymKeyGenerator::NapiSymKeyGenerator(HcfSymKeyGenerator *generator) NapiSymKeyGenerator::~NapiSymKeyGenerator() { - OH_HCF_OBJ_DESTROY(this->generator_); + HcfObjDestroy(this->generator_); } -HcfSymKeyGenerator *NapiSymKeyGenerator::GetSymKeyGenerator() +HcfSymKeyGenerator *NapiSymKeyGenerator::GetSymKeyGenerator() const { return this->generator_; } napi_value NapiSymKeyGenerator::JsGenerateSymKey(napi_env env, napi_callback_info info) { - SymKeyGeneratorFwkCtx context = (SymKeyGeneratorFwkCtx)HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0); + SymKeyGeneratorFwkCtx context = static_cast(HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0)); if (context == nullptr) { LOGE("Create context failed!"); return nullptr; @@ -340,7 +345,7 @@ napi_value NapiSymKeyGenerator::JsGenerateSymKey(napi_env env, napi_callback_inf napi_value NapiSymKeyGenerator::JsConvertKey(napi_env env, napi_callback_info info) { - SymKeyGeneratorFwkCtx context = (SymKeyGeneratorFwkCtx)HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0); + SymKeyGeneratorFwkCtx context = static_cast(HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0)); if (context == nullptr) { LOGE("malloc SymKeyGeneratorFwkCtx failed!"); return nullptr; @@ -370,12 +375,12 @@ napi_value NapiSymKeyGenerator::SymKeyGeneratorConstructor(napi_env env, napi_ca napi_value NapiSymKeyGenerator::CreateSymKeyGenerator(napi_env env, napi_callback_info info) { - size_t exceptedArgc = ARGS_SIZE_ONE; + size_t expectedArgc = ARGS_SIZE_ONE; size_t argc = ARGS_SIZE_ONE; - napi_value argv[ARGS_SIZE_ONE] = { 0 }; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "The input args num is invalid.")); LOGE("The input args num is invalid."); return nullptr; @@ -387,12 +392,12 @@ napi_value NapiSymKeyGenerator::CreateSymKeyGenerator(napi_env env, napi_callbac NAPI_CALL(env, napi_new_instance(env, constructor, argc, argv, &instance)); std::string algoName; - if (!GetStringFromJSParams(env, argv[ARGS_SIZE_ZERO], algoName)) { + if (!GetStringFromJSParams(env, argv[0], algoName)) { LOGE("failed to get algoName."); return nullptr; } - HcfSymKeyGenerator *generator = NULL; + HcfSymKeyGenerator *generator = nullptr; int32_t res = HcfSymKeyGeneratorCreate(algoName.c_str(), &generator); if (res != HCF_SUCCESS) { napi_throw(env, GenerateBusinessError(env, res, "create C generator fail.")); @@ -402,7 +407,7 @@ napi_value NapiSymKeyGenerator::CreateSymKeyGenerator(napi_env env, napi_callbac NapiSymKeyGenerator *napiSymKeyGenerator = new (std::nothrow) NapiSymKeyGenerator(generator); if (napiSymKeyGenerator == nullptr) { LOGE("new napiSymKeyGenerator failed!"); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); return nullptr; } @@ -427,12 +432,12 @@ napi_value NapiSymKeyGenerator::JsGetAlgorithm(napi_env env, napi_callback_info napi_value thisVar = nullptr; NapiSymKeyGenerator *napiSymKeyGenerator = nullptr; NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr)); - NAPI_CALL(env, napi_unwrap(env, thisVar, (void **)&napiSymKeyGenerator)); + NAPI_CALL(env, napi_unwrap(env, thisVar, reinterpret_cast(&napiSymKeyGenerator))); HcfSymKeyGenerator *generator = napiSymKeyGenerator->GetSymKeyGenerator(); const char *algo = generator->getAlgoName(generator); napi_value instance = nullptr; - napi_create_string_utf8(env, (const char *)algo, NAPI_AUTO_LENGTH, &instance); + napi_create_string_utf8(env, algo, NAPI_AUTO_LENGTH, &instance); return instance; } diff --git a/frameworks/js/napi/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp similarity index 55% rename from frameworks/js/napi/src/napi_utils.cpp rename to frameworks/js/napi/crypto/src/napi_utils.cpp index 09eb0ad6a52df4de1f6c7fb92532201854372bd5..c7d1e206233ea5abb086757449e9733e9d977d5a 100644 --- a/frameworks/js/napi/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -35,159 +35,6 @@ napi_value NapiGetNull(napi_env env) return result; } -napi_value ConvertArrayToNapiValue(napi_env env, HcfArray *array) -{ - if (array == nullptr) { - LOGE("array is null!"); - return nullptr; - } - if (array->count == 0) { - LOGE("array count is 0!"); - return nullptr; - } - napi_value returnArray = nullptr; - napi_create_array(env, &returnArray); - if (returnArray == nullptr) { - LOGE("create return array failed!"); - return nullptr; - } - for (uint32_t i = 0; i < array->count; i++) { - HcfBlob *blob = (HcfBlob *)(array->data + i); - napi_value outBuffer = GenerateArrayBuffer(env, blob->data, blob->len); - if (outBuffer == nullptr) { - LOGE("generate array buffer failed!"); - return nullptr; - } - napi_value element = nullptr; - napi_create_typedarray(env, napi_uint8_array, blob->len, outBuffer, 0, &element); - napi_set_element(env, returnArray, i, element); - } - napi_value returnValue = nullptr; - napi_create_object(env, &returnValue); - napi_set_named_property(env, returnValue, CRYPTO_TAG_DATA.c_str(), returnArray); - return returnValue; -} - -napi_value GenerateArrayBuffer(napi_env env, uint8_t *data, uint32_t size) -{ - uint8_t *buffer = (uint8_t *)HcfMalloc(size, 0); - if (buffer == nullptr) { - LOGE("malloc uint8 array buffer failed!"); - return nullptr; - } - - if (memcpy_s(buffer, size, data, size) != EOK) { - LOGE("memcpy_s data to buffer failed!"); - HcfFree(buffer); - return nullptr; - } - - napi_value outBuffer = nullptr; - napi_status status = napi_create_external_arraybuffer( - env, buffer, size, [](napi_env env, void *data, void *hint) { HcfFree(data); }, nullptr, &outBuffer); - if (status != napi_ok) { - LOGE("create uint8 array buffer failed!"); - HcfFree(buffer); - return nullptr; - } - buffer = nullptr; - return outBuffer; -} - -static bool GetDataOfEncodingBlob(napi_env env, napi_value data, HcfEncodingBlob *encodingBlob) -{ - napi_typedarray_type arrayType; - napi_value arrayBuffer = nullptr; - size_t length = 0; - size_t offset = 0; - void *rawData = nullptr; - - napi_status status = napi_get_typedarray_info(env, data, &arrayType, &length, - (void **)&rawData, &arrayBuffer, &offset); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get array data failed")); - LOGE("failed to get array data!"); - return false; - } - if (arrayType != napi_uint8_array) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "array type is not uint8 array")); - LOGE("array is not uint8 array!"); - return false; - } - - if (length == 0) { - LOGE("input data length is 0"); - return false; - } - encodingBlob->data = (uint8_t *)HcfMalloc(length, 0); - if (encodingBlob->data == nullptr) { - LOGE("malloc encoding blob data failed!"); - return false; - } - if (memcpy_s(encodingBlob->data, length, rawData, length) != EOK) { - LOGE("memcpy_s encoding blob data failed!"); - HcfFree(encodingBlob->data); - encodingBlob->data = nullptr; - return false; - } - encodingBlob->len = length; - return true; -} - -bool GetEncodingBlobFromValue(napi_env env, napi_value obj, HcfEncodingBlob **encodingBlob) -{ - *encodingBlob = (HcfEncodingBlob *)HcfMalloc(sizeof(HcfEncodingBlob), 0); - if (*encodingBlob == nullptr) { - LOGE("malloc encoding blob failed!"); - return false; - } - napi_value data = nullptr; - napi_status status = napi_get_named_property(env, obj, CRYPTO_TAG_DATA.c_str(), &data); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get encoding blob data failed")); - LOGE("failed to get encoding blob data!"); - HcfFree(*encodingBlob); - *encodingBlob = nullptr; - return false; - } - if (!GetDataOfEncodingBlob(env, data, *encodingBlob)) { - HcfFree(*encodingBlob); - *encodingBlob = nullptr; - return false; - } - napi_value format = nullptr; - status = napi_get_named_property(env, obj, CRYPTO_TAG_ENCODING_FORMAT.c_str(), &format); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get encoding blob format failed")); - LOGE("failed to get encoding blob format!"); - HcfFree((*encodingBlob)->data); - (*encodingBlob)->data = nullptr; - HcfFree(*encodingBlob); - *encodingBlob = nullptr; - return false; - } - napi_get_value_uint32(env, format, (uint32_t *)(&(*encodingBlob)->encodingFormat)); - return true; -} - -napi_value ConvertEncodingBlobToNapiValue(napi_env env, HcfEncodingBlob *encodingBlob) -{ - napi_value outBuffer = GenerateArrayBuffer(env, encodingBlob->data, encodingBlob->len); - if (outBuffer == nullptr) { - LOGE("generate array buffer failed!"); - return nullptr; - } - napi_value outData = nullptr; - napi_create_typedarray(env, napi_uint8_array, encodingBlob->len, outBuffer, 0, &outData); - napi_value encoding = nullptr; - napi_create_uint32(env, encodingBlob->encodingFormat, &encoding); - napi_value returnEncodingBlob = nullptr; - napi_create_object(env, &returnEncodingBlob); - napi_set_named_property(env, returnEncodingBlob, CRYPTO_TAG_DATA.c_str(), outData); - napi_set_named_property(env, returnEncodingBlob, CRYPTO_TAG_ENCODING_FORMAT.c_str(), encoding); - return returnEncodingBlob; -} - HcfBlob *GetBlobFromNapiValue(napi_env env, napi_value arg) { if ((env == nullptr) || (arg == nullptr)) { @@ -207,7 +54,8 @@ HcfBlob *GetBlobFromNapiValue(napi_env env, napi_value arg) napi_value arrayBuffer = nullptr; napi_typedarray_type arrayType; // Warning: Do not release the rawData returned by this interface because the rawData is managed by VM. - status = napi_get_typedarray_info(env, data, &arrayType, &length, (void **)&rawData, &arrayBuffer, &offset); + status = napi_get_typedarray_info(env, data, &arrayType, &length, + reinterpret_cast(&rawData), &arrayBuffer, &offset); if ((status != napi_ok) || (length == 0) || (rawData == nullptr)) { LOGE("failed to get valid rawData."); return nullptr; @@ -217,13 +65,13 @@ HcfBlob *GetBlobFromNapiValue(napi_env env, napi_value arg) return nullptr; } - HcfBlob *newBlob = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); - if (newBlob == NULL) { + HcfBlob *newBlob = reinterpret_cast(HcfMalloc(sizeof(HcfBlob), 0)); + if (newBlob == nullptr) { LOGE("Failed to allocate newBlob memory!"); return nullptr; } newBlob->len = length; - newBlob->data = (uint8_t *)HcfMalloc(length, 0); + newBlob->data = static_cast(HcfMalloc(length, 0)); if (newBlob->data == nullptr) { LOGE("malloc blob data failed!"); HcfFree(newBlob); @@ -254,7 +102,7 @@ static const char *GetCcmParamsSpecType() return CCM_PARAMS_SPEC.c_str(); } -static HcfBlob *GetBlobFromParamsSpec(napi_env env, napi_value arg, string type) +static HcfBlob *GetBlobFromParamsSpec(napi_env env, napi_value arg, const string &type) { napi_value data = nullptr; HcfBlob *blob = nullptr; @@ -274,7 +122,7 @@ static HcfBlob *GetBlobFromParamsSpec(napi_env env, napi_value arg, string type) static bool GetIvParamsSpec(napi_env env, napi_value arg, HcfParamsSpec **paramsSpec) { - HcfIvParamsSpec *ivParamsSpec = (HcfIvParamsSpec *)HcfMalloc(sizeof(HcfIvParamsSpec), 0); + HcfIvParamsSpec *ivParamsSpec = reinterpret_cast(HcfMalloc(sizeof(HcfIvParamsSpec), 0)); if (ivParamsSpec == nullptr) { LOGE("ivParamsSpec malloc failed!"); return false; @@ -288,7 +136,7 @@ static bool GetIvParamsSpec(napi_env env, napi_value arg, HcfParamsSpec **params } ivParamsSpec->base.getType = GetIvParamsSpecType; ivParamsSpec->iv = *iv; - *paramsSpec = (HcfParamsSpec *)ivParamsSpec; + *paramsSpec = reinterpret_cast(ivParamsSpec); HcfFree(iv); return true; } @@ -319,7 +167,7 @@ static bool GetGcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, HcfBlob authTag = {}; bool ret = false; - HcfGcmParamsSpec *gcmParamsSpec = (HcfGcmParamsSpec *)HcfMalloc(sizeof(HcfGcmParamsSpec), 0); + HcfGcmParamsSpec *gcmParamsSpec = reinterpret_cast(HcfMalloc(sizeof(HcfGcmParamsSpec), 0)); if (gcmParamsSpec == nullptr) { LOGE("gcmParamsSpec malloc failed!"); return false; @@ -338,7 +186,7 @@ static bool GetGcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, goto clearup; } } else if (opMode == ENCRYPT_MODE) { - authTag.data = (uint8_t *)HcfMalloc(GCM_AUTH_TAG_LEN, 0); + authTag.data = static_cast(HcfMalloc(GCM_AUTH_TAG_LEN, 0)); if (authTag.data == nullptr) { LOGE("get tag failed!"); goto clearup; @@ -352,7 +200,7 @@ static bool GetGcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, gcmParamsSpec->iv = *iv; gcmParamsSpec->aad = *aad; gcmParamsSpec->tag = opMode == DECRYPT_MODE ? *tag : authTag; - *paramsSpec = (HcfParamsSpec *)gcmParamsSpec; + *paramsSpec = reinterpret_cast(gcmParamsSpec); ret = true; clearup: if (!ret) { @@ -375,7 +223,7 @@ static bool GetCcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, HcfBlob authTag = {}; bool ret = false; - HcfCcmParamsSpec *ccmParamsSpec = (HcfCcmParamsSpec *)HcfMalloc(sizeof(HcfCcmParamsSpec), 0); + HcfCcmParamsSpec *ccmParamsSpec = reinterpret_cast(HcfMalloc(sizeof(HcfCcmParamsSpec), 0)); if (ccmParamsSpec == nullptr) { LOGE("ccmParamsSpec malloc failed!"); return ret; @@ -393,7 +241,7 @@ static bool GetCcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, goto clearup; } } else if (opMode == ENCRYPT_MODE) { - authTag.data = (uint8_t *)HcfMalloc(CCM_AUTH_TAG_LEN, 0); + authTag.data = static_cast(HcfMalloc(CCM_AUTH_TAG_LEN, 0)); if (authTag.data == nullptr) { LOGE("get tag failed!"); goto clearup; @@ -406,7 +254,7 @@ static bool GetCcmParamsSpec(napi_env env, napi_value arg, HcfCryptoMode opMode, ccmParamsSpec->iv = *iv; ccmParamsSpec->aad = *aad; ccmParamsSpec->tag = opMode == DECRYPT_MODE ? *tag : authTag; - *paramsSpec = (HcfParamsSpec *)ccmParamsSpec; + *paramsSpec = reinterpret_cast(ccmParamsSpec); ret = true; clearup: if (!ret) { @@ -424,15 +272,21 @@ clearup: bool GetParamsSpecFromNapiValue(napi_env env, napi_value arg, HcfCryptoMode opMode, HcfParamsSpec **paramsSpec) { napi_value data = nullptr; + napi_valuetype valueType = napi_undefined; if ((env == nullptr) || (arg == nullptr) || (paramsSpec == nullptr)) { LOGE("Invalid parmas!"); return false; } napi_status status = napi_get_named_property(env, arg, ALGO_PARAMS.c_str(), &data); - if ((status != napi_ok) || (data == nullptr)) { - LOGE("failed to get valid algo name!"); - return false; + napi_typeof(env, data, &valueType); + if ((status != napi_ok) || (data == nullptr) || (valueType == napi_undefined)) { + status = napi_get_named_property(env, arg, ALGO_PARAMS_OLD.c_str(), &data); + napi_typeof(env, data, &valueType); + if ((status != napi_ok) || (data == nullptr) || (valueType == napi_undefined)) { + LOGE("failed to get valid algo name!"); + return false; + } } string algoName; if (!GetStringFromJSParams(env, data, algoName)) { @@ -456,7 +310,7 @@ napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob) LOGE("Invalid blob!"); return nullptr; } - uint8_t *buffer = (uint8_t *)HcfMalloc(blob->len, 0); + uint8_t *buffer = static_cast(HcfMalloc(blob->len, 0)); if (buffer == nullptr) { LOGE("malloc uint8 array buffer failed!"); return nullptr; @@ -487,96 +341,6 @@ napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob) return dataBlob; } -static bool GetDataOfCertChain(napi_env env, napi_value data, HcfCertChainData *certChain) -{ - napi_typedarray_type arrayType; - napi_value arrayBuffer = nullptr; - size_t length = 0; - size_t offset = 0; - void *rawData = nullptr; - - napi_status status = napi_get_typedarray_info(env, data, &arrayType, &length, - (void **)&rawData, &arrayBuffer, &offset); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get array data failed")); - LOGE("failed to get array data!"); - return false; - } - if (arrayType != napi_uint8_array) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "array type is not uint8 array")); - LOGE("array is not uint8 array!"); - return false; - } - - if (length == 0) { - LOGE("input data length is 0"); - return false; - } - certChain->data = (uint8_t *)HcfMalloc(length, 0); - if (certChain->data == nullptr) { - LOGE("malloc cert chain data failed!"); - return false; - } - if (memcpy_s(certChain->data, length, rawData, length) != EOK) { - LOGE("memcpy_s cert chain data failed!"); - HcfFree(certChain->data); - certChain->data = nullptr; - return false; - } - certChain->dataLen = length; - return true; -} - -bool GetCertChainFromValue(napi_env env, napi_value obj, HcfCertChainData **certChainData) -{ - *certChainData = (HcfCertChainData *)HcfMalloc(sizeof(HcfCertChainData), 0); - if (*certChainData == nullptr) { - LOGE("malloc certChainData failed!"); - return false; - } - napi_value data = nullptr; - napi_status status = napi_get_named_property(env, obj, CRYPTO_TAG_DATA.c_str(), &data); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain data failed")); - LOGE("failed to get cert chain data!"); - HcfFree(*certChainData); - *certChainData = nullptr; - return false; - } - if (!GetDataOfCertChain(env, data, *certChainData)) { - HcfFree(*certChainData); - *certChainData = nullptr; - return false; - } - - napi_value certCount = nullptr; - status = napi_get_named_property(env, obj, CRYPTO_TAG_COUNT.c_str(), &certCount); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain count failed")); - LOGE("failed to get cert count!"); - HcfFree((*certChainData)->data); - (*certChainData)->data = nullptr; - HcfFree(*certChainData); - *certChainData = nullptr; - return false; - } - napi_get_value_uint32(env, certCount, (uint32_t *)(&(*certChainData)->count)); - - napi_value format = nullptr; - status = napi_get_named_property(env, obj, CRYPTO_TAG_ENCODING_FORMAT.c_str(), &format); - if (status != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get cert chain format failed")); - LOGE("failed to get cert chain format!"); - HcfFree((*certChainData)->data); - (*certChainData)->data = nullptr; - HcfFree(*certChainData); - *certChainData = nullptr; - return false; - } - napi_get_value_uint32(env, format, (uint32_t *)(&(*certChainData)->format)); - return true; -} - bool GetStringFromJSParams(napi_env env, napi_value arg, string &returnStr) { napi_valuetype valueType; @@ -659,21 +423,9 @@ static uint32_t GetJsErrValueByErrCode(int32_t errCode) case HCF_ERR_MALLOC: return JS_ERR_OUT_OF_MEMORY; case HCF_ERR_COPY: - return JS_ERR_INTERNAL_ERROR; + return JS_ERR_RUNTIME_ERROR; case HCF_ERR_CRYPTO_OPERATION: return JS_ERR_CRYPTO_OPERATION; - case HCF_ERR_CERT_SIGNATURE_FAILURE: - return JS_ERR_CERT_SIGNATURE_FAILURE; - case HCF_ERR_CERT_NOT_YET_VALID: - return JS_ERR_CERT_NOT_YET_VALID; - case HCF_ERR_CERT_HAS_EXPIRED: - return JS_ERR_CERT_HAS_EXPIRED; - case HCF_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: - return JS_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY; - case HCF_ERR_KEYUSAGE_NO_CERTSIGN: - return JS_ERR_KEYUSAGE_NO_CERTSIGN; - case HCF_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE: - return JS_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE; default: return JS_ERR_DEFAULT_ERR; } diff --git a/frameworks/js/napi/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp similarity index 90% rename from frameworks/js/napi/src/napi_verify.cpp rename to frameworks/js/napi/crypto/src/napi_verify.cpp index 1c421707674c8c37be998c5e57896e00f35504d8..5d4c1e8fc0fcc94b080ef92df8447a73dacc6b5b 100644 --- a/frameworks/js/napi/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -70,7 +70,8 @@ struct VerifyDoFinalCtx { HcfBlob *data; HcfBlob *signatureData; - bool result; + int32_t result; + bool isVerifySucc; }; thread_local napi_ref NapiVerify::classRef_ = nullptr; @@ -142,7 +143,7 @@ static bool BuildVerifyJsInitCtx(napi_env env, napi_callback_info info, VerifyIn { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { @@ -152,8 +153,8 @@ static bool BuildVerifyJsInitCtx(napi_env env, napi_callback_info info, VerifyIn } ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiVerify *napiVerify = NULL; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiVerify)); + NapiVerify *napiVerify = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); if (status != napi_ok) { LOGE("failed to unwrap napi verify obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -161,8 +162,8 @@ static bool BuildVerifyJsInitCtx(napi_env env, napi_callback_info info, VerifyIn } size_t index = 0; - NapiPubKey *napiPubKey = NULL; - status = napi_unwrap(env, argv[index], (void **)(&napiPubKey)); + NapiPubKey *napiPubKey = nullptr; + status = napi_unwrap(env, argv[index], reinterpret_cast(&napiPubKey)); if (status != napi_ok) { LOGE("failed to unwrap napi pubKey obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[PubKey]: param unwarp error.")); @@ -185,7 +186,7 @@ static bool BuildVerifyJsUpdateCtx(napi_env env, napi_callback_info info, Verify { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { @@ -195,8 +196,8 @@ static bool BuildVerifyJsUpdateCtx(napi_env env, napi_callback_info info, Verify } ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiVerify *napiVerify = NULL; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiVerify)); + NapiVerify *napiVerify = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); if (status != napi_ok) { LOGE("failed to unwrap napi verify obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "params num error.")); @@ -231,7 +232,8 @@ static bool GetDataBlobAndSignatureFromInput(napi_env env, napi_value dataValue, data = GetBlobFromNapiValue(env, dataValue); if (data == nullptr) { LOGE("failed to get data."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Data]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, + "[Data]: must be of the DataBlob type.")); return false; } } @@ -255,7 +257,7 @@ static bool BuildVerifyJsDoFinalCtx(napi_env env, napi_callback_info info, Verif { napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_THREE; - size_t argc; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_THREE] = { nullptr, nullptr, nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { @@ -266,7 +268,7 @@ static bool BuildVerifyJsDoFinalCtx(napi_env env, napi_callback_info info, Verif ctx->asyncType = (argc == expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; NapiVerify *napiVerify = nullptr; - napi_status status = napi_unwrap(env, thisVar, (void **)(&napiVerify)); + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); if (status != napi_ok) { LOGE("failed to unwrap napi verify obj."); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[Self]: param unwarp error.")); @@ -282,6 +284,7 @@ static bool BuildVerifyJsDoFinalCtx(napi_env env, napi_callback_info info, Verif ctx->verify = napiVerify->GetVerify(); ctx->data = data; ctx->signatureData = signatureData; + ctx->result = HCF_ERR_CRYPTO_OPERATION; if (ctx->asyncType == ASYNC_PROMISE) { napi_create_promise(env, &ctx->deferred, &ctx->promise); @@ -314,7 +317,8 @@ static void ReturnInitPromiseResult(napi_env env, VerifyInitCtx *ctx, napi_value if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, + GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); } } @@ -341,7 +345,8 @@ static void ReturnUpdatePromiseResult(napi_env env, VerifyUpdateCtx *ctx, napi_v if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { - napi_reject_deferred(env, ctx->deferred, GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); + napi_reject_deferred(env, ctx->deferred, + GenerateBusinessError(env, ctx->result, COMMON_ERR_MSG.c_str())); } } @@ -365,7 +370,7 @@ static void ReturnDoFinalCallbackResult(napi_env env, VerifyDoFinalCtx *ctx, nap static void ReturnDoFinalPromiseResult(napi_env env, VerifyDoFinalCtx *ctx, napi_value result) { - if (ctx->result) { + if (ctx->result == HCF_SUCCESS) { napi_resolve_deferred(env, ctx->deferred, result); } else { napi_reject_deferred(env, ctx->deferred, @@ -425,10 +430,10 @@ void VerifyJsDoFinalAsyncWorkProcess(napi_env env, void *data) { VerifyDoFinalCtx *ctx = static_cast(data); - bool res = ctx->verify->verify(ctx->verify, ctx->data, ctx->signatureData); + ctx->isVerifySucc = ctx->verify->verify(ctx->verify, ctx->data, ctx->signatureData); + ctx->result = HCF_SUCCESS; - ctx->result = res; - if (!res) { + if (!ctx->isVerifySucc) { LOGE("verify doFinal fail."); return; } @@ -439,7 +444,9 @@ void VerifyJsDoFinalAsyncWorkReturn(napi_env env, napi_status status, void *data VerifyDoFinalCtx *ctx = static_cast(data); napi_value result = nullptr; - napi_get_boolean(env, ctx->result, &result); + if (ctx->result == HCF_SUCCESS) { + napi_get_boolean(env, ctx->isVerifySucc, &result); + } if (ctx->asyncType == ASYNC_CALLBACK) { ReturnDoFinalCallbackResult(env, ctx, result); @@ -464,7 +471,7 @@ static napi_value NewVerifyJsInitAsyncWork(napi_env env, VerifyInitCtx *ctx) VerifyJsInitAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -492,7 +499,7 @@ static napi_value NewVerifyJsUpdateAsyncWork(napi_env env, VerifyUpdateCtx *ctx) VerifyJsUpdateAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -520,7 +527,7 @@ static napi_value NewVerifyJsDoFinalAsyncWork(napi_env env, VerifyDoFinalCtx *ct VerifyJsDoFinalAsyncWorkReturn(env, status, data); return; }, - (void *)ctx, + static_cast(ctx), &ctx->asyncWork); napi_queue_async_work(env, ctx->asyncWork); @@ -540,7 +547,7 @@ NapiVerify::NapiVerify(HcfVerify *verify) NapiVerify::~NapiVerify() { - OH_HCF_OBJ_DESTROY(this->verify_); + HcfObjDestroy(this->verify_); } HcfVerify *NapiVerify::GetVerify() @@ -551,10 +558,10 @@ HcfVerify *NapiVerify::GetVerify() napi_value NapiVerify::JsInit(napi_env env, napi_callback_info info) { LOGI("enter ..."); - VerifyInitCtx *ctx = (VerifyInitCtx *)HcfMalloc(sizeof(VerifyInitCtx), 0); - if (ctx == NULL) { + VerifyInitCtx *ctx = static_cast(HcfMalloc(sizeof(VerifyInitCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildVerifyJsInitCtx(env, info, ctx)) { @@ -569,10 +576,10 @@ napi_value NapiVerify::JsInit(napi_env env, napi_callback_info info) napi_value NapiVerify::JsUpdate(napi_env env, napi_callback_info info) { LOGI("enter ..."); - VerifyUpdateCtx *ctx = (VerifyUpdateCtx *)HcfMalloc(sizeof(VerifyUpdateCtx), 0); - if (ctx == NULL) { + VerifyUpdateCtx *ctx = static_cast(HcfMalloc(sizeof(VerifyUpdateCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildVerifyJsUpdateCtx(env, info, ctx)) { @@ -587,10 +594,10 @@ napi_value NapiVerify::JsUpdate(napi_env env, napi_callback_info info) napi_value NapiVerify::JsVerify(napi_env env, napi_callback_info info) { LOGI("enter ..."); - VerifyDoFinalCtx *ctx = (VerifyDoFinalCtx *)HcfMalloc(sizeof(VerifyDoFinalCtx), 0); - if (ctx == NULL) { + VerifyDoFinalCtx *ctx = static_cast(HcfMalloc(sizeof(VerifyDoFinalCtx), 0)); + if (ctx == nullptr) { LOGE("create context fail."); - return NULL; + return nullptr; } if (!BuildVerifyJsDoFinalCtx(env, info, ctx)) { @@ -616,12 +623,12 @@ napi_value NapiVerify::VerifyConstructor(napi_env env, napi_callback_info info) napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) { LOGI("enter ..."); - size_t exceptedArgc = PARAMS_NUM_ONE; - size_t argc; + size_t expectedArgc = PARAMS_NUM_ONE; + size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); - if (argc != exceptedArgc) { + if (argc != expectedArgc) { LOGE("The input args num is invalid."); return nullptr; } @@ -637,7 +644,7 @@ napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) return nullptr; } - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate(algName.c_str(), &verify); if (res != HCF_SUCCESS) { LOGE("create c verify fail."); @@ -649,7 +656,7 @@ napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) napi_wrap( env, instance, napiVerify, [](napi_env env, void *data, void *hint) { - NapiVerify *napiVerify = (NapiVerify *)(data); + NapiVerify *napiVerify = static_cast(data); delete napiVerify; return; }, diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index 46edbb398c38e3b70b7b15cfe6a5f50d28fe247a..878eeede0f780ab837d5b81ba6cfe3125da7ae70 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -39,7 +39,7 @@ typedef struct { typedef struct { HCF_ALG_VALUE algo; - HcfAsyKeyGeneratorSpiCreateFunc createSpifunc; + HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc; } HcfAsyKeyGenAbility; static const HcfAsyKeyGenAbility ASY_KEY_GEN_ABILITY_SET[] = { @@ -51,7 +51,7 @@ static HcfAsyKeyGeneratorSpiCreateFunc FindAbility(HcfAsyKeyGenParams *params) { for (uint32_t i = 0; i < sizeof(ASY_KEY_GEN_ABILITY_SET) / sizeof(ASY_KEY_GEN_ABILITY_SET[0]); i++) { if (ASY_KEY_GEN_ABILITY_SET[i].algo == params->algo) { - return ASY_KEY_GEN_ABILITY_SET[i].createSpifunc; + return ASY_KEY_GEN_ABILITY_SET[i].createSpiFunc; } } LOGE("Algo not support! [Algo]: %d", params->algo); @@ -91,7 +91,7 @@ static void SetKeyType(HCF_ALG_PARA_VALUE value, HcfAsyKeyGenParams *params) case HCF_ALG_ECC_224: case HCF_ALG_ECC_256: case HCF_ALG_ECC_384: - case HCF_ALG_ECC_512: + case HCF_ALG_ECC_521: params->bits = value; params->algo = HCF_ALG_ECC; break; @@ -206,7 +206,7 @@ static void DestroyAsyKeyGenerator(HcfObjectBase *self) return; } HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); impl->spiObj = NULL; HcfFree(impl); } @@ -223,8 +223,8 @@ HcfResult HcfAsyKeyGeneratorCreate(const char *algoName, HcfAsyKeyGenerator **re return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorSpiCreateFunc createSpifunc = FindAbility(¶ms); - if (createSpifunc == NULL) { + HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(¶ms); + if (createSpiFunc == NULL) { return HCF_NOT_SUPPORT; } @@ -240,7 +240,7 @@ HcfResult HcfAsyKeyGeneratorCreate(const char *algoName, HcfAsyKeyGenerator **re } HcfAsyKeyGeneratorSpi *spiObj = NULL; int32_t res = HCF_SUCCESS; - res = createSpifunc(¶ms, &spiObj); + res = createSpiFunc(¶ms, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnGenerator); diff --git a/frameworks/key/sym_key_generator.c b/frameworks/key/sym_key_generator.c index 79dc89517a34ad0aef10fa7aca6c567b0a8f3266..b45bd2bca832c8efd26d0631d4c403d40263b725 100644 --- a/frameworks/key/sym_key_generator.c +++ b/frameworks/key/sym_key_generator.c @@ -30,7 +30,7 @@ #define AES_KEY_SIZE_256 256 #define DES_KEY_SIZE_192 192 -typedef HcfResult (*SymKeyGeneratorSpiCreateFunc)(SymKeyAttr *, OH_HCF_SymKeyGeneratorSpi **); +typedef HcfResult (*SymKeyGeneratorSpiCreateFunc)(SymKeyAttr *, HcfSymKeyGeneratorSpi **); typedef struct { SymKeyGeneratorSpiCreateFunc createFunc; @@ -43,7 +43,7 @@ typedef struct { typedef struct { HcfSymKeyGenerator base; - OH_HCF_SymKeyGeneratorSpi *spiObj; + HcfSymKeyGeneratorSpi *spiObj; char algoName[HCF_MAX_ALGO_NAME_LEN]; } HcfSymmKeyGeneratorImpl; @@ -57,8 +57,8 @@ static const SymKeyGenFuncSet *FindAbility(SymKeyAttr *attr) if (attr == NULL) { return NULL; } - for (uint32_t i = 0; i < sizeof(SYMKEY_ABILITY_SET); i++) { - if (SYMKEY_ABILITY_SET[i].algo == attr->algo) { + for (uint32_t i = 0; i < sizeof(SYMKEY_ABILITY_SET) / sizeof(SymKeyGenAbility); i++) { + if (SYMKEY_ABILITY_SET[i].algo == attr->algo) { return &(SYMKEY_ABILITY_SET[i].funcSet); } } @@ -86,6 +86,7 @@ static void SetKeyLength(HCF_ALG_PARA_VALUE value, void *attr) case HCF_ALG_3DES_192: keyAttr->algo = HCF_ALG_DES; keyAttr->keySize = DES_KEY_SIZE_192; + break; default: break; } @@ -138,9 +139,7 @@ static void DestroySymmKeyGenerator(HcfObjectBase *base) return; } HcfSymmKeyGeneratorImpl *impl = (HcfSymmKeyGeneratorImpl *)base; - if (impl->spiObj != NULL) { - OH_HCF_OBJ_DESTROY((HcfObjectBase *)impl->spiObj); - } + HcfObjDestroy(impl->spiObj); HcfFree(impl); } @@ -175,9 +174,9 @@ static HcfResult ConvertSymmKey(HcfSymKeyGenerator *self, const HcfBlob *key, Hc return impl->spiObj->engineConvertSymmKey(impl->spiObj, key, symmKey); } -HcfResult HcfSymKeyGeneratorCreate(const char *algoName, HcfSymKeyGenerator **generator) +HcfResult HcfSymKeyGeneratorCreate(const char *algoName, HcfSymKeyGenerator **returnObj) { - if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (generator == NULL)) { + if (!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN) || (returnObj == NULL)) { LOGE("Invalid input params while creating symkey!"); return HCF_INVALID_PARAMS; } @@ -203,7 +202,7 @@ HcfResult HcfSymKeyGeneratorCreate(const char *algoName, HcfSymKeyGenerator **ge HcfFree(returnGenerator); return HCF_ERR_COPY; } - OH_HCF_SymKeyGeneratorSpi *spiObj = NULL; + HcfSymKeyGeneratorSpi *spiObj = NULL; int32_t res = funcSet->createFunc(&attr, &spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); @@ -217,6 +216,6 @@ HcfResult HcfSymKeyGeneratorCreate(const char *algoName, HcfSymKeyGenerator **ge returnGenerator->base.getAlgoName = GetAlgoName; returnGenerator->spiObj = spiObj; - *generator = (HcfSymKeyGenerator *)returnGenerator; + *returnObj = (HcfSymKeyGenerator *)returnGenerator; return HCF_SUCCESS; } diff --git a/frameworks/rand/rand.c b/frameworks/rand/rand.c index 9485489e9eaccbb23a271ac50bd631fb284d189c..5bbd0cd0b8d5752399b90ea375ae05fcbbe360b7 100644 --- a/frameworks/rand/rand.c +++ b/frameworks/rand/rand.c @@ -35,7 +35,7 @@ typedef struct { typedef struct { char *algoName; - HcfRandSpiCreateFunc createSpifunc; + HcfRandSpiCreateFunc createSpiFunc; } HcfRandAbility; static const HcfRandAbility RAND_ABILITY_SET[] = { @@ -51,7 +51,7 @@ static HcfRandSpiCreateFunc FindAbility(const char *algoName) { for (uint32_t i = 0; i < (sizeof(RAND_ABILITY_SET) / sizeof(RAND_ABILITY_SET[0])); i++) { if (strcmp(RAND_ABILITY_SET[i].algoName, algoName) == 0) { - return RAND_ABILITY_SET[i].createSpifunc; + return RAND_ABILITY_SET[i].createSpiFunc; } } LOGE("Algo not support! [Algo]: %s", algoName); @@ -82,8 +82,9 @@ static HcfResult SetSeed(HcfRand *self, HcfBlob *seed) LOGE("Class is not match."); return HCF_INVALID_PARAMS; } - return ((HcfRandImpl *)self)->spiObj->engineSetSeed( + ((HcfRandImpl *)self)->spiObj->engineSetSeed( ((HcfRandImpl *)self)->spiObj, seed); + return HCF_SUCCESS; } static void HcfRandDestroy(HcfObjectBase *self) @@ -97,18 +98,18 @@ static void HcfRandDestroy(HcfObjectBase *self) return; } HcfRandImpl *impl = (HcfRandImpl *)self; - OH_HCF_OBJ_DESTROY(impl->spiObj); + HcfObjDestroy(impl->spiObj); HcfFree(impl); } -HcfResult HcfRandCreate(HcfRand **randApi) +HcfResult HcfRandCreate(HcfRand **random) { - if (randApi == NULL) { + if (random == NULL) { LOGE("Invalid input params while creating rand!"); return HCF_INVALID_PARAMS; } - HcfRandSpiCreateFunc createSpifunc = FindAbility("OpensslRand"); - if (createSpifunc == NULL) { + HcfRandSpiCreateFunc createSpiFunc = FindAbility("OpensslRand"); + if (createSpiFunc == NULL) { LOGE("Algo not supported!"); return HCF_NOT_SUPPORT; } @@ -118,7 +119,7 @@ HcfResult HcfRandCreate(HcfRand **randApi) return HCF_ERR_MALLOC; } HcfRandSpi *spiObj = NULL; - HcfResult res = createSpifunc(&spiObj); + HcfResult res = createSpiFunc(&spiObj); if (res != HCF_SUCCESS) { LOGE("Failed to create spi object!"); HcfFree(returnRandApi); @@ -129,6 +130,6 @@ HcfResult HcfRandCreate(HcfRand **randApi) returnRandApi->base.generateRandom = GenerateRandom; returnRandApi->base.setSeed = SetSeed; returnRandApi->spiObj = spiObj; - *randApi = (HcfRand *)returnRandApi; + *random = (HcfRand *)returnRandApi; return HCF_SUCCESS; } \ No newline at end of file diff --git a/frameworks/spi/asy_key_generator_spi.h b/frameworks/spi/asy_key_generator_spi.h index 95f341ff977e46c08355b670a9554f3c68db93ea..c88fa4d3a935b78b4f0d0af34d776e0a69c38101 100644 --- a/frameworks/spi/asy_key_generator_spi.h +++ b/frameworks/spi/asy_key_generator_spi.h @@ -25,11 +25,11 @@ #define OPENSSL_RSA_GENERATOR_CLASS "OPENSSL.RSA.KEYGENERATOR" -#define OPENSSL_RSA_KEY_FORMAT "OPENSSL.RSA.KEYFORMAT.DEFAULT" +#define OPENSSL_RSA_PUBKEY_FORMAT "X.509" -#define OPENSSL_RSA_ALGORITHM "OPENSSL.RSA" +#define OPENSSL_RSA_PRIKEY_FORMAT "PKCS#8" -#define OPENSSL_RSA_KEY_FORMAT "OPENSSL.RSA.KEYFORMAT.DEFAULT" +#define OPENSSL_RSA_ALGORITHM "OPENSSL.RSA" typedef struct HcfAsyKeyGeneratorSpi HcfAsyKeyGeneratorSpi; diff --git a/frameworks/spi/cipher_factory_spi.h b/frameworks/spi/cipher_factory_spi.h index d53bb8a0bb196bb64150b26023c59adb52fa2aa2..1806bd955963d639ab7366db35d61bd60175c080 100644 --- a/frameworks/spi/cipher_factory_spi.h +++ b/frameworks/spi/cipher_factory_spi.h @@ -24,17 +24,17 @@ #include "result.h" #include "params_parser.h" -typedef struct OH_HCF_CipherGeneratorSpi OH_HCF_CipherGeneratorSpi; +typedef struct HcfCipherGeneratorSpi HcfCipherGeneratorSpi; -struct OH_HCF_CipherGeneratorSpi { +struct HcfCipherGeneratorSpi { HcfObjectBase base; - HcfResult (*init)(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode opMode, + HcfResult (*init)(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params); - HcfResult (*update)(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output); + HcfResult (*update)(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output); - HcfResult (*doFinal)(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output); + HcfResult (*doFinal)(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output); }; #endif diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 6c81b513b6fc0cd921dac4e72b0cba178b14a043..5825d79235613412100b1532cc563ecff3e26369 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -28,7 +28,7 @@ struct HcfRandSpi { HcfResult (*engineGenerateRandom)(HcfRandSpi *self, int32_t numBytes, HcfBlob *random); - HcfResult (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); + void (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); }; #endif \ No newline at end of file diff --git a/frameworks/spi/sym_key_factory_spi.h b/frameworks/spi/sym_key_factory_spi.h index c8ff9dc3bca0080508c6ba440803e7c2d306dfa1..5fbf4cc54055dcc3d86a98f34d138e13d6c2d301 100644 --- a/frameworks/spi/sym_key_factory_spi.h +++ b/frameworks/spi/sym_key_factory_spi.h @@ -20,12 +20,12 @@ #include "result.h" #include "sym_key.h" -typedef struct OH_HCF_SymKeyGeneratorSpi OH_HCF_SymKeyGeneratorSpi; +typedef struct HcfSymKeyGeneratorSpi HcfSymKeyGeneratorSpi; -struct OH_HCF_SymKeyGeneratorSpi { +struct HcfSymKeyGeneratorSpi { HcfObjectBase base; - HcfResult (*engineGenerateSymmKey)(OH_HCF_SymKeyGeneratorSpi *self, HcfSymKey **symmKey); - HcfResult (*engineConvertSymmKey)(OH_HCF_SymKeyGeneratorSpi *self, const HcfBlob *key, HcfSymKey **symmKey); + HcfResult (*engineGenerateSymmKey)(HcfSymKeyGeneratorSpi *self, HcfSymKey **symmKey); + HcfResult (*engineConvertSymmKey)(HcfSymKeyGeneratorSpi *self, const HcfBlob *key, HcfSymKey **symmKey); }; #define OPENSSL_SYM_GENERATOR_CLASS "OPENSSL.SYM.KEYGENERATOR" #define OPENSSL_SYM_KEY_CLASS "OPENSSL.SYM.KEY" diff --git a/frameworks/spi/x509_certificate_spi.h b/frameworks/spi/x509_certificate_spi.h index e7642cd16a4d58b090c44aeea722a690c0580ce8..d081eed89a7e1d73b414bc1af8f79c9e4d5418bb 100644 --- a/frameworks/spi/x509_certificate_spi.h +++ b/frameworks/spi/x509_certificate_spi.h @@ -36,7 +36,7 @@ struct HcfX509CertificateSpi { long (*engineGetVersion)(HcfX509CertificateSpi *self); - long (*engineGetSerialNumber)(HcfX509CertificateSpi *self); + HcfResult (*engineGetSerialNumber)(HcfX509CertificateSpi *self, HcfBlob *out); HcfResult (*engineGetIssuerName)(HcfX509CertificateSpi *self, HcfBlob *out); diff --git a/interfaces/innerkits/certificate/x509_certificate.h b/interfaces/innerkits/certificate/x509_certificate.h index 75b5b360bb9718049ffd30493128fd2e1184b414..bc3cd978aa096fc43ed8be19b177f54ccf30dfea 100644 --- a/interfaces/innerkits/certificate/x509_certificate.h +++ b/interfaces/innerkits/certificate/x509_certificate.h @@ -35,7 +35,7 @@ struct HcfX509Certificate { long (*getVersion)(HcfX509Certificate *self); /** Get serial number from certificate. */ - long (*getSerialNumber)(HcfX509Certificate *self); + HcfResult (*getSerialNumber)(HcfX509Certificate *self, HcfBlob *out); /** Get issuer distinguished name from certificate. */ HcfResult (*getIssuerName)(HcfX509Certificate *self, HcfBlob *out); diff --git a/interfaces/innerkits/certificate/x509_crl_entry.h b/interfaces/innerkits/certificate/x509_crl_entry.h index e106563ebb0bb8b268a8aa3e4894678115730468..2be4120807c8ce0738706a956c4fbd792d14c8af 100644 --- a/interfaces/innerkits/certificate/x509_crl_entry.h +++ b/interfaces/innerkits/certificate/x509_crl_entry.h @@ -30,7 +30,7 @@ struct HcfX509CrlEntry { HcfResult (*getEncoded)(HcfX509CrlEntry *self, HcfEncodingBlob *encodedOut); /** Get the serial number from this x509crl entry. */ - long (*getSerialNumber)(HcfX509CrlEntry *self); + HcfResult (*getSerialNumber)(HcfX509CrlEntry *self, HcfBlob *out); /** Gets the issuer of the x509 certificate described by this entry. */ HcfResult (*getCertIssuer)(HcfX509CrlEntry *self, HcfBlob *encodedOut); diff --git a/interfaces/innerkits/common/blob.h b/interfaces/innerkits/common/blob.h index 34f71443a0a0bcd9d33ce6ee7e802b7183265ee6..28090ae7aef1b6b73d83b83534795ce62c75ffb0 100644 --- a/interfaces/innerkits/common/blob.h +++ b/interfaces/innerkits/common/blob.h @@ -48,7 +48,7 @@ extern "C" { void HcfBlobDataFree(HcfBlob *blob); void HcfBlobDataClearAndFree(HcfBlob *blob); -void HcfEncodingBlobDataFree(HcfEncodingBlob *blob); +void HcfEncodingBlobDataFree(HcfEncodingBlob *encodingBlob); void HcfArrayDataClearAndFree(HcfArray *array); #ifdef __cplusplus diff --git a/interfaces/innerkits/common/object_base.h b/interfaces/innerkits/common/object_base.h index 0648c505989c8f1151b35f6b4d6480436a597f8b..f2345f5e4c25036beea51785927de0d8e8778b09 100644 --- a/interfaces/innerkits/common/object_base.h +++ b/interfaces/innerkits/common/object_base.h @@ -23,9 +23,14 @@ struct HcfObjectBase { void (*destroy)(HcfObjectBase *self); }; -#define OH_HCF_OBJ_DESTROY(base) \ - if ((base) != NULL) { \ - ((HcfObjectBase *)(base))->destroy((HcfObjectBase *)(base)); \ - } +#ifdef __cplusplus +extern "C" { +#endif + +void HcfObjDestroy(void *obj); + +#ifdef __cplusplus +} +#endif #endif // HCF_OBJECT_BASE_H diff --git a/interfaces/innerkits/crypto_operation/cipher.h b/interfaces/innerkits/crypto_operation/cipher.h index 0454c3d734e6790179e9daec5e7a6a3dad961b08..885b51e43494cbdb76adc473e564dc25a1bf1ba2 100644 --- a/interfaces/innerkits/crypto_operation/cipher.h +++ b/interfaces/innerkits/crypto_operation/cipher.h @@ -64,13 +64,13 @@ extern "C" { /** * @brief Generate a corresponding cryptographic operation cipher object according to the algorithm name. * - * @param algoName Specifies the type of generated cipher object. + * @param transformation Specifies the type of generated cipher object. * @param returnObj The address of the pointer to the generated cipher object. * @return Returns the status code of the execution. * @since 9 * @version 1.0 */ -HcfResult HcfCipherCreate(const char *algoName, HcfCipher **returnObj); +HcfResult HcfCipherCreate(const char *transformation, HcfCipher **returnObj); #ifdef __cplusplus } diff --git a/interfaces/kits/js/@ohos.security.cryptoFramework.d.ts b/interfaces/kits/js/@ohos.security.cryptoFramework.d.ts deleted file mode 100644 index 32278aeac30e4ec3d5176d3cc54c8460d26d4b46..0000000000000000000000000000000000000000 --- a/interfaces/kits/js/@ohos.security.cryptoFramework.d.ts +++ /dev/null @@ -1,481 +0,0 @@ -/* - * Copyright (c) 2022 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 {AsyncCallback, Callback} from './basic'; - -/** - * Provides a set of encryption and decryption algorithm library framework, shields the underlying differences, - * encapsulates the relevant algorithm library, and provides a unified functional interface upward. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - */ -declare namespace cryptoFramework { - /** - * Enum for result code - * @since 9 - */ - enum Result { - /** Indicates that input params is invalid. - * @since 9 - */ - INVALID_PARAMS = 401, - - /** Indicates that function or algorithm is not supported. - * @since 9 - */ - NOT_SUPPORT = 801, - - /** Indicates the out of memory error. - * @since 9 - */ - ERR_OUT_OF_MEMORY = 17620001, - - /** Indicates that internal error. - * @since 9 - */ - ERR_INTERNAL_ERROR = 17620002, - - /** Indicates that crypto operation has something wrong. - * @since 9 - */ - ERR_CRYPTO_OPERATION = 17630001, - - /* Indicates that cert signature check fails. - * @since 9 - */ - ERR_CERT_SIGNATURE_FAILURE = 17630002, - - /* Indicates that cert is not yet valid. - * @since 9 - */ - ERR_CERT_NOT_YET_VALID = 17630003, - - /* Indicates that cert has expired. - * @since 9 - */ - ERR_CERT_HAS_EXPIRED = 17630004, - - /* Indicates that we can not get the untrusted cert's issuer. - * @since 9 - */ - ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 17630005, - - /* Key usage does not include certificate sign. - * @since 9 - */ - ERR_KEYUSAGE_NO_CERTSIGN = 17630006, - - /* Key usage does not include digital sign. - * @since 9 - */ - ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = 17630007, - } - - interface DataBlob { - data : Uint8Array; - } - - interface DataArray { - data : Array; - } - - /** - * Enum for supported cert encoding format - * @since 9 - */ - enum EncodingFormat { - /** - * The value of cert DER format - * @since 9 - */ - FORMAT_DER = 0, - - /** - * The value of cert PEM format - * @since 9 - */ - FORMAT_PEM = 1, - } - - interface EncodingBlob { - data : Uint8Array; - encodingFormat : EncodingFormat; - } - - interface CertChainData { - data: Uint8Array; - count : number; - encodingFormat: EncodingFormat; - } - - interface ParamsSpec { - algoName : string; - } - - interface IvParamsSpec extends ParamsSpec { - iv : DataBlob; - } - - interface GcmParamsSpec extends ParamsSpec { - iv : DataBlob; - aad : DataBlob; - authTag : DataBlob; - } - - interface CcmParamsSpec extends ParamsSpec { - iv : DataBlob; - aad : DataBlob; - authTag : DataBlob; - } - - /** - * Enum for obtain the crypto operation. - * @since 9 - */ - enum CryptoMode { - /** - * The value of aes and 3des encrypt operation - * @since 9 - */ - ENCRYPT_MODE = 0, - - /** - * The value of aes and 3des decrypt operation - * @since 9 - */ - DECRYPT_MODE = 1, - } - - interface Key { - getEncoded() : DataBlob; - readonly format : string; - readonly algName : string; - } - - interface SymKey extends Key { - clearMem() : void; - } - - interface PriKey extends Key { - clearMem() : void; - } - - interface PubKey extends Key {} - - interface KeyPair { - readonly priKey : PriKey; - readonly pubKey : PubKey; - } - - interface Random { - generateRandom(len : number, callback: AsyncCallback) : void; - generateRandom(len : number) : Promise; - setSeed(seed : DataBlob, callback : AsyncCallback) : void; - setSeed(seed : DataBlob) : Promise; - } - - /** - * Provides the rand create func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param callback Indicates the callback for the rand create result. - */ - function createRandom() : Random; - - interface AsyKeyGenerator { - generateKeyPair(callback : AsyncCallback) : void; - generateKeyPair() : Promise; - convertKey(pubKey : DataBlob, priKey : DataBlob, callback : AsyncCallback) : void; - convertKey(pubKey : DataBlob, priKey : DataBlob) : Promise; - readonly algName : string; - } - - interface SymKeyGenerator { - generateSymKey(callback : AsyncCallback) : void; - generateSymKey() : Promise; - convertKey(key : DataBlob, callback : AsyncCallback) : void; - convertKey(key : DataBlob) : Promise; - readonly algName : string; - } - - /** - * Provides the asy key generator instance func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the algorithm name. - */ - function createAsyKeyGenerator(algName : string) : AsyKeyGenerator; - - /** - * Provides the sym key generator instance func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the algorithm name. - * @param callback Indicates the callback for get the sym key generator instance result. - */ - function createSymKeyGenerator(algName : string) : SymKeyGenerator; - - interface Mac { - init(key : SymKey, callback : AsyncCallback) : void; - init(key : SymKey) : Promise; - update(input : DataBlob, callback : AsyncCallback) : void; - update(input : DataBlob) : Promise; - doFinal(callback : AsyncCallback) : void; - doFinal() : Promise; - getMacLength() : number; - readonly algName : string; - } - - /** - * Provides the mac create func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the mac algorithm name. - * @param callback Indicates the callback for the mac create result. - */ - function createMac(algName : string) : Mac; - - interface Md { - update(input : DataBlob, callback : AsyncCallback) : void; - update(input : DataBlob) : Promise; - digest(callback : AsyncCallback) : void; - digest() : Promise; - getMdLength() : number; - readonly algName : string; - } - - /** - * Provides the md create func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algorithm Indicates the md algorithm. - * @param callback Indicates the callback for the md create result. - */ - function createMd(algName : string) : Md; - - interface Cipher { - init(opMode : CryptoMode, key : Key, params : ParamsSpec, callback : AsyncCallback) : void; - init(opMode : CryptoMode, key : Key, params : ParamsSpec) : Promise; - update(data : DataBlob, callback : AsyncCallback) : void; - update(data : DataBlob) : Promise; - doFinal(data : DataBlob, callback : AsyncCallback) : void; - doFinal(data : DataBlob) : Promise; - readonly algName : string; - } - - /** - * Provides the cipher create func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param transformation Indicates the transform type. - * @param callback Indicates the callback for the cipher create result. - */ - function createCipher(transformation : string) : Cipher; - - interface Sign { - init(priKey : PriKey, callback : AsyncCallback) : void; - init(priKey : PriKey) : Promise; - update(data : DataBlob, callback : AsyncCallback) : void; - update(data : DataBlob) : Promise; - sign(data : DataBlob, callback : AsyncCallback) : void; - sign(data : DataBlob) : Promise; - readonly algName : string; - } - - interface Verify { - init(pubKey : PubKey, callback : AsyncCallback) : void; - init(pubKey : PubKey) : Promise; - update(data : DataBlob, callback : AsyncCallback) : void; - update(data : DataBlob) : Promise; - verify(data : DataBlob, signatureData : DataBlob, callback : AsyncCallback) : void; - verify(data : DataBlob, signatureData : DataBlob) : Promise; - readonly algName : string; - } - - /** - * Provides the sign func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the sign algorithm name. - */ - function createSign(algName : string) : Sign; - - /** - * Provides the verify func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the verify algorithm name. - */ - function createVerify(algName : string) : Verify; - - interface KeyAgreement { - generateSecret(priKey : PriKey, pubKey : PubKey, callback : AsyncCallback) : void; - generateSecret(priKey : PriKey, pubKey : PubKey) : Promise; - readonly algName : string; - } - - /** - * Provides the key agree func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algName Indicates the key agreement algorithm name. - */ - function createKeyAgreement(algName : string) : KeyAgreement; - - interface X509Cert { - verify(key : PubKey, callback : AsyncCallback) : void; - verify(key : PubKey) : Promise; - getEncoded(callback : AsyncCallback) : void; - getEncoded() : Promise; - getPublicKey(callback : AsyncCallback) : void; - getPublicKey() : Promise; - checkValidityWithDate(date: string, callback : AsyncCallback) : void; - checkValidityWithDate(date: string) : Promise; - getVersion() : number; - getSerialNumber() : number; - getIssuerName() : DataBlob; - getSubjectName() : DataBlob; - getNotBeforeTime() : string; - getNotAfterTime() : string; - getSignature() : DataBlob; - getSignatureAlgName() : string; - getSignatureAlgOid() : string; - getSignatureAlgParams() : DataBlob; - getKeyUsage() : DataBlob; - getExtKeyUsage() : DataArray; - getBasicConstraints() : number; - getSubjectAltNames() : DataArray; - getIssuerAltNames() : DataArray; - } - - /** - * Provides the x509 cert func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param inStream Indicates the input cert data. - * @param callback Indicates the callback for the x509 cert create. - */ - function createX509Cert(inStream : EncodingBlob, callback : AsyncCallback) : void; - function createX509Cert(inStream : EncodingBlob) : Promise; - - interface X509CrlEntry { - getEncoded(callback : AsyncCallback) : void; - getEncoded() : Promise; - getSerialNumber() : number; - getCertIssuer(callback : AsyncCallback) : void; - getCertIssuer() : Promise; - getRevocationDate(callback : AsyncCallback) : void; - getRevocationDate() : Promise; - } - - interface X509Crl { - isRevoked(cert : X509Cert, callback : AsyncCallback) : void; - isRevoked(cert : X509Cert) : Promise; - getType() : string; - getEncoded(callback : AsyncCallback) : void; - getEncoded() : Promise; - verify(key : PubKey, callback : AsyncCallback) : void; - verify(key : PubKey) : Promise; - getVersion() : number; - getIssuerName() : DataBlob; - getLastUpdate() : string; - getNextUpdate() : string; - getRevokedCert(serialNumber : number, callback : AsyncCallback) : void; - getRevokedCert(serialNumber : number) : Promise; - getRevokedCertWithCert(cert : X509Cert, callback : AsyncCallback) : void; - getRevokedCertWithCert(cert : X509Cert) : Promise; - getRevokedCerts(callback : AsyncCallback>) : void; - getRevokedCerts() : Promise>; - getTbsInfo(callback : AsyncCallback) : void; - getTbsInfo() : Promise; - getSignature() : DataBlob; - getSignatureAlgName() : string; - getSignatureAlgOid() : string; - getSignatureAlgParams() : DataBlob; - } - - /** - * Provides the x509 CRL func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param inStream Indicates the input CRL data. - * @param callback Indicates the callback for the x509 CRL create. - */ - function createX509Crl(inStream : EncodingBlob, callback : AsyncCallback) : void; - function createX509Crl(inStream : EncodingBlob) : Promise; - - /** - * Certification chain validator. - * @since 9 - * @syscap SystemCapability.Security.CryptoFramework - */ - - interface CertChainValidator { - validate(certChain : CertChainData, callback : AsyncCallback) : void; - validate(certChain : CertChainData) : Promise; - readonly algorithm : string; - } - - /** - * Provides the cert chain validator func. - * - * @sysCap SystemCapability.Security.CryptoFramework. - * @import import cryptoFramework from '@ohos.security.cryptoFramework' - * @permission - * @since 9 - * @param algorithm Indicates the cert chain validator type. - * @param callback Indicates the callback for the cert chain validator result. - */ - function createCertChainValidator(algorithm :string) : CertChainValidator; -} - -export default cryptoFramework; diff --git a/plugin/BUILD.gn b/plugin/BUILD.gn index a53f079ca8626cd4c3f153c490fa062e22ec3ad9..8145e5af35622738d9c20e3d730c1579f4f22eee 100644 --- a/plugin/BUILD.gn +++ b/plugin/BUILD.gn @@ -39,7 +39,64 @@ ohos_shared_library("crypto_openssl_plugin_lib") { sources = plugin_files + if (os_level == "standard") { + sanitize = { + cfi = true + debug = false + } + } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + deps = [ + "//base/security/crypto_framework/common:crypto_plugin_common", + "//third_party/openssl:libcrypto_shared", + ] + + external_deps = [ + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + ] +} + +ohos_shared_library("certificate_openssl_plugin_lib") { + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = [ + "//commonlibrary/c_utils/base/include", + "//third_party/openssl/include/", + ] + include_dirs += [ + "//base/security/crypto_framework/interfaces/innerkits/certificate", + "//base/security/crypto_framework/interfaces/innerkits/common", + "//base/security/crypto_framework/interfaces/innerkits/key", + "openssl_plugin/certificate/inc", + "//base/security/crypto_framework/frameworks/spi", + "//base/security/crypto_framework/common/inc", + ] + include_dirs += crypto_framwork_common_inc_path + + sources = [ + "openssl_plugin/certificate/src/certificate_openssl_common.c", + "openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c", + "openssl_plugin/certificate/src/x509_certificate_openssl.c", + "openssl_plugin/certificate/src/x509_crl_entry_openssl.c", + "openssl_plugin/certificate/src/x509_crl_openssl.c", + ] + + if (os_level == "standard") { + sanitize = { + cfi = true + debug = false + } + } + cflags = [ + "-DHILOG_ENABLE", "-fPIC", "-Wall", ] @@ -49,5 +106,8 @@ ohos_shared_library("crypto_openssl_plugin_lib") { "//third_party/openssl:libcrypto_shared", ] - external_deps = [ "c_utils:utils" ] + external_deps = [ + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + ] } diff --git a/plugin/openssl_plugin/certificate/inc/certificate_openssl_class.h b/plugin/openssl_plugin/certificate/inc/certificate_openssl_class.h new file mode 100644 index 0000000000000000000000000000000000000000..345210b0a3ac63d147a23fdb8bb3a697a6025074 --- /dev/null +++ b/plugin/openssl_plugin/certificate/inc/certificate_openssl_class.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2023 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 CF_CERTIFICATE_OEPNSSL_CLASS_H +#define CF_CERTIFICATE_OEPNSSL_CLASS_H + +#include "pub_key.h" +#include "pri_key.h" +#include "x509_certificate_spi.h" +#include "x509_crl_entry.h" +#include "x509_crl.h" +#include "x509_crl_spi.h" + +#include +#include +#include +#include +#include + +typedef struct { + HcfPubKey base; + + uint32_t bits; + + RSA *pk; +} HcfOpensslRsaPubKey; +#define OPENSSL_RSA_PUBKEY_CLASS "OPENSSL.RSA.PUB_KEY" + +typedef struct { + HcfPriKey base; + + uint32_t bits; + + RSA *sk; +} HcfOpensslRsaPriKey; +#define OPENSSL_RSA_PRIKEY_CLASS "OPENSSL.RSA.PRI_KEY" + +typedef struct { + HcfX509CertificateSpi base; + X509 *x509; +} HcfOpensslX509Cert; +#define X509_CERT_OPENSSL_CLASS "X509CertOpensslClass" + +typedef struct { + HcfX509CrlEntry base; + X509_REVOKED *rev; + HcfBlob *certIssuer; +} HcfX509CRLEntryOpensslImpl; +#define X509_CRL_ENTRY_OPENSSL_CLASS "X509CrlEntryOpensslClass" + +typedef struct { + HcfX509Crl base; + HcfX509CrlSpi *spiObj; + const char *certType; +} HcfX509CrlImpl; +#define X509_CRL_OPENSSL_CLASS "X509CrlOpensslClass" + +#endif diff --git a/plugin/openssl_plugin/certificate/inc/certificate_openssl_common.h b/plugin/openssl_plugin/certificate/inc/certificate_openssl_common.h new file mode 100644 index 0000000000000000000000000000000000000000..5aacc8df1da1e21f8f333dd8fed346005b493327 --- /dev/null +++ b/plugin/openssl_plugin/certificate/inc/certificate_openssl_common.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2023 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 CF_CERTIFICATE_OPENSSL_COMMON_H +#define CF_CERTIFICATE_OPENSSL_COMMON_H + +#include + +#define CF_OPENSSL_SUCCESS 1 /* openssl return 1: success */ + +#ifdef __cplusplus +extern "C" { +#endif + +const char *GetAlgorithmName(const char *oid); +void CfPrintOpensslError(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/plugin/openssl_plugin/certificate/src/certificate_openssl_common.c b/plugin/openssl_plugin/certificate/src/certificate_openssl_common.c new file mode 100644 index 0000000000000000000000000000000000000000..695245d4d61c1a2b622caeb8edd0300bd0fe9510 --- /dev/null +++ b/plugin/openssl_plugin/certificate/src/certificate_openssl_common.c @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2023 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 "certificate_openssl_common.h" + +#include +#include +#include "config.h" +#include "log.h" +#include "result.h" + +typedef struct { + char *oid; + char *algorithmName; +} OidToAlgorithmName; + +static const OidToAlgorithmName g_oidToNameMap[] = { + { "1.2.840.113549.1.1.2", "MD2withRSA" }, + { "1.2.840.113549.1.1.4", "MD5withRSA" }, + { "1.2.840.113549.1.1.5", "SHA1withRSA" }, + { "1.2.840.10040.4.3", "SHA1withDSA" }, + { "1.2.840.10045.4.1", "SHA1withECDSA" }, + { "1.2.840.113549.1.1.14", "SHA224withRSA" }, + { "1.2.840.113549.1.1.11", "SHA256withRSA" }, + { "1.2.840.113549.1.1.12", "SHA384withRSA" }, + { "1.2.840.113549.1.1.13", "SHA512withRSA" }, + { "2.16.840.1.101.3.4.3.1", "SHA224withDSA" }, + { "2.16.840.1.101.3.4.3.2", "SHA256withDSA" }, + { "1.2.840.10045.4.3.1", "SHA224withECDSA" }, + { "1.2.840.10045.4.3.2", "SHA256withECDSA" }, + { "1.2.840.10045.4.3.3", "SHA384withECDSA" }, + { "1.2.840.10045.4.3.4", "SHA512withECDSA" } +}; + +const char *GetAlgorithmName(const char *oid) +{ + if (oid == NULL) { + LOGE("Oid is null!"); + return NULL; + } + + uint32_t oidCount = sizeof(g_oidToNameMap) / sizeof(OidToAlgorithmName); + for (uint32_t i = 0; i < oidCount; i++) { + if (strcmp(g_oidToNameMap[i].oid, oid) == 0) { + return g_oidToNameMap[i].algorithmName; + } + } + LOGE("Can not find algorithmName! [oid]: %s", oid); + return NULL; +} + +void CfPrintOpensslError(void) +{ + char szErr[LOG_PRINT_MAX_LEN] = {0}; + unsigned long errCode; + + errCode = ERR_get_error(); + ERR_error_string_n(errCode, szErr, LOG_PRINT_MAX_LEN); + + LOGE("[Openssl]: engine fail, error code = %lu, error string = %s", errCode, szErr); +} diff --git a/plugin/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c b/plugin/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c index 61ef2f587d466b66b82f81e1d3bee13692fe17e6..b51f3ae940e910487fd072787bbf7a9e9a3dd671 100644 --- a/plugin/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c +++ b/plugin/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c @@ -31,7 +31,7 @@ #include "memory.h" #include "utils.h" #include "result.h" -#include "openssl_common.h" +#include "certificate_openssl_common.h" #define X509_CERT_CHAIN_VALIDATOR_OPENSSL_CLASS "X509CertChainValidatorOpensslClass" @@ -149,9 +149,9 @@ static HcfResult ValidateCertChainInner(CertsInfo *certs, uint32_t certNum) } for (uint32_t i = certNum - 1; i > 0; i--) { // certs[certNum - 1] represents the 0th cert. - if (X509_STORE_add_cert(store, certs[i].x509) != HCF_OPENSSL_SUCCESS) { + if (X509_STORE_add_cert(store, certs[i].x509) != CF_OPENSSL_SUCCESS) { LOGE("Failed to add cert to store."); - HcfPrintOpensslError(); + CfPrintOpensslError(); res = HCF_ERR_MALLOC; break; } @@ -162,14 +162,14 @@ static HcfResult ValidateCertChainInner(CertsInfo *certs, uint32_t certNum) /* Do not check cert validity against current time. */ X509_STORE_set_flags(store, X509_V_FLAG_NO_CHECK_TIME); int32_t resOpenssl = X509_STORE_CTX_init(verifyCtx, store, certs[0].x509, NULL); - if (resOpenssl != HCF_OPENSSL_SUCCESS) { + if (resOpenssl != CF_OPENSSL_SUCCESS) { LOGE("Failed to init verify ctx."); res = HCF_ERR_CRYPTO_OPERATION; - HcfPrintOpensslError(); + CfPrintOpensslError(); break; } resOpenssl = X509_verify_cert(verifyCtx); - if (resOpenssl != HCF_OPENSSL_SUCCESS) { + if (resOpenssl != CF_OPENSSL_SUCCESS) { int32_t errCode = X509_STORE_CTX_get_error(verifyCtx); const char *pChError = X509_verify_cert_error_string(errCode); LOGE("Failed to verify cert, openssl openssl error code = %d, error msg:%s.", errCode, pChError); diff --git a/plugin/openssl_plugin/certificate/src/x509_certificate_openssl.c b/plugin/openssl_plugin/certificate/src/x509_certificate_openssl.c index c12f5086e7707538f54947105244115d33c2d34a..2749b698442cb7c0880c587fa6c3473376107bd0 100644 --- a/plugin/openssl_plugin/certificate/src/x509_certificate_openssl.c +++ b/plugin/openssl_plugin/certificate/src/x509_certificate_openssl.c @@ -27,8 +27,8 @@ #include "result.h" #include "utils.h" #include "x509_certificate.h" -#include "openssl_class.h" -#include "openssl_common.h" +#include "certificate_openssl_class.h" +#include "certificate_openssl_common.h" #define X509_CERT_PUBLIC_KEY_OPENSSL_CLASS "X509CertPublicKeyOpensslClass" #define OID_STR_MAX_LEN 128 @@ -48,12 +48,7 @@ static HcfResult DeepCopyDataToOut(const char *data, uint32_t len, HcfBlob *out) LOGE("Failed to malloc for sig algorithm params!"); return HCF_ERR_MALLOC; } - if (memcpy_s(out->data, len, data, len) != EOK) { - LOGE("Failed to copy the sig algorithm params!"); - HcfFree(out->data); - out->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(out->data, len, data, len); out->len = len; return HCF_SUCCESS; } @@ -138,9 +133,9 @@ static HcfResult VerifyX509Openssl(HcfX509CertificateSpi *self, HcfPubKey *key) X509 *x509 = realCert->x509; X509PubKeyOpensslImpl *keyImpl = (X509PubKeyOpensslImpl *)key; EVP_PKEY *pubKey = keyImpl->pubKey; - if (X509_verify(x509, pubKey) != HCF_OPENSSL_SUCCESS) { + if (X509_verify(x509, pubKey) != CF_OPENSSL_SUCCESS) { LOGE("Failed to verify x509 cert's signature."); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } return HCF_SUCCESS; @@ -161,7 +156,7 @@ static HcfResult GetEncodedX509Openssl(HcfX509CertificateSpi *self, HcfEncodingB int32_t length = i2d_X509(x509, NULL); if ((length <= 0) || (x509 == NULL)) { LOGE("Failed to convert internal x509 to der format!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } unsigned char *der = NULL; @@ -172,13 +167,7 @@ static HcfResult GetEncodedX509Openssl(HcfX509CertificateSpi *self, HcfEncodingB OPENSSL_free(der); return HCF_ERR_MALLOC; } - if (memcpy_s(encodedByte->data, length, der, length) != EOK) { - LOGE("Failed to copy the x509 der data!"); - OPENSSL_free(der); - HcfFree(encodedByte->data); - encodedByte->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(encodedByte->data, length, der, length); OPENSSL_free(der); encodedByte->len = length; encodedByte->encodingFormat = HCF_FORMAT_DER; @@ -200,7 +189,7 @@ static HcfResult GetPublicKeyX509Openssl(HcfX509CertificateSpi *self, HcfPubKey EVP_PKEY *pubKey = X509_get_pubkey(x509); if (pubKey == NULL) { LOGE("Failed to get publick key from x509 cert."); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } X509PubKeyOpensslImpl *keyImpl = (X509PubKeyOpensslImpl *)HcfMalloc(sizeof(X509PubKeyOpensslImpl), 0); @@ -225,7 +214,7 @@ static HcfResult CompareDateWithCertTime(const X509 *x509, const ASN1_TIME *inpu ASN1_TIME *expirationDate = X509_get_notAfter(x509); if ((startDate == NULL) || (expirationDate == NULL)) { LOGE("Date is null in x509 cert!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = HCF_SUCCESS; @@ -257,9 +246,9 @@ static HcfResult CheckValidityWithDateX509Openssl(HcfX509CertificateSpi *self, c LOGE("Failed to malloc for asn1 time."); return HCF_ERR_MALLOC; } - if (ASN1_TIME_set_string(asn1InputDate, date) != HCF_OPENSSL_SUCCESS) { + if (ASN1_TIME_set_string(asn1InputDate, date) != CF_OPENSSL_SUCCESS) { LOGE("Failed to set time for asn1 time."); - HcfPrintOpensslError(); + CfPrintOpensslError(); ASN1_TIME_free(asn1InputDate); return HCF_ERR_CRYPTO_OPERATION; } @@ -283,24 +272,36 @@ static long GetVersionX509Openssl(HcfX509CertificateSpi *self) return X509_get_version(x509) + 1; } -static long GetSerialNumberX509Openssl(HcfX509CertificateSpi *self) +static HcfResult GetSerialNumberX509Openssl(HcfX509CertificateSpi *self, HcfBlob *out) { if (self == NULL) { LOGE("The input data is null!"); - return INVALID_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetX509CertClass())) { LOGE("Input wrong class type!"); - return INVALID_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } HcfOpensslX509Cert *realCert = (HcfOpensslX509Cert *)self; X509 *x509 = realCert->x509; const ASN1_INTEGER *serial = X509_get0_serialNumber(x509); if (serial == NULL) { LOGE("Failed to get serial number!"); - return INVALID_SERIAL_NUMBER; + return HCF_ERR_CRYPTO_OPERATION; } - return ASN1_INTEGER_get(serial); + + unsigned char *serialNumBytes = NULL; + int serialNumLen = i2d_ASN1_INTEGER((ASN1_INTEGER *)serial, &serialNumBytes); + if (serialNumLen <= SERIAL_NUMBER_HEDER_SIZE) { + CfPrintOpensslError(); + LOGE("Failed to get serialNumLen!"); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = DeepCopyDataToOut((const char *)(serialNumBytes + SERIAL_NUMBER_HEDER_SIZE), + (uint32_t)(serialNumLen - SERIAL_NUMBER_HEDER_SIZE), out); + OPENSSL_free(serialNumBytes); + return ret; } static HcfResult GetIssuerDNX509Openssl(HcfX509CertificateSpi *self, HcfBlob *out) @@ -318,7 +319,7 @@ static HcfResult GetIssuerDNX509Openssl(HcfX509CertificateSpi *self, HcfBlob *ou X509_NAME *issuerName = X509_get_issuer_name(x509); if (issuerName == NULL) { LOGE("Failed to get x509 issuerName in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } char *issuer = (char *)HcfMalloc(HCF_MAX_STR_LEN + 1, 0); @@ -334,7 +335,7 @@ static HcfResult GetIssuerDNX509Openssl(HcfX509CertificateSpi *self, HcfBlob *ou if (length == 1) { LOGE("Failed to get oneline issuerName in openssl!"); res = HCF_ERR_CRYPTO_OPERATION; - HcfPrintOpensslError(); + CfPrintOpensslError(); break; } res = DeepCopyDataToOut(issuer, length, out); @@ -358,7 +359,7 @@ static HcfResult GetSubjectDNX509Openssl(HcfX509CertificateSpi *self, HcfBlob *o X509_NAME *subjectName = X509_get_subject_name(x509); if (subjectName == NULL) { LOGE("Failed to get x509 subjectName in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } char *subject = (char *)HcfMalloc(HCF_MAX_STR_LEN + 1, 0); @@ -373,7 +374,7 @@ static HcfResult GetSubjectDNX509Openssl(HcfX509CertificateSpi *self, HcfBlob *o size_t length = strlen(subject) + 1; if (length == 1) { LOGE("Failed to get oneline subjectName in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); res = HCF_ERR_CRYPTO_OPERATION; break; } @@ -398,12 +399,12 @@ static HcfResult GetNotBeforeX509Openssl(HcfX509CertificateSpi *self, HcfBlob *o ASN1_TIME *notBeforeDate = X509_get_notBefore(x509); if (notBeforeDate == NULL) { LOGE("NotBeforeDate is null in x509 cert!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (ASN1_TIME_normalize(notBeforeDate) != HCF_OPENSSL_SUCCESS) { + if (ASN1_TIME_normalize(notBeforeDate) != CF_OPENSSL_SUCCESS) { LOGE("Failed to normalize notBeforeDate!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *date = (const char *)(notBeforeDate->data); @@ -430,12 +431,12 @@ static HcfResult GetNotAfterX509Openssl(HcfX509CertificateSpi *self, HcfBlob *ou ASN1_TIME *notAfterDate = X509_get_notAfter(x509); if (notAfterDate == NULL) { LOGE("NotAfterDate is null in x509 cert!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (ASN1_TIME_normalize(notAfterDate) != HCF_OPENSSL_SUCCESS) { + if (ASN1_TIME_normalize(notAfterDate) != CF_OPENSSL_SUCCESS) { LOGE("Failed to normalize notAfterDate!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *date = (const char *)(notAfterDate->data); @@ -463,7 +464,7 @@ static HcfResult GetSignatureX509Openssl(HcfX509CertificateSpi *self, HcfBlob *s X509_get0_signature(&signature, NULL, x509); if ((signature == NULL) || (signature->length == 0) || (signature->length > HCF_MAX_BUFFER_LEN)) { LOGE("Failed to get x509 signature in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } sigOut->data = (uint8_t *)HcfMalloc(signature->length, 0); @@ -471,12 +472,7 @@ static HcfResult GetSignatureX509Openssl(HcfX509CertificateSpi *self, HcfBlob *s LOGE("Failed to malloc for signature data!"); return HCF_ERR_MALLOC; } - if (memcpy_s(sigOut->data, signature->length, signature->data, signature->length) != EOK) { - LOGE("Failed to copy the signature data!"); - HcfFree(sigOut->data); - sigOut->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(sigOut->data, signature->length, signature->data, signature->length); sigOut->len = signature->length; return HCF_SUCCESS; } @@ -501,7 +497,7 @@ static HcfResult GetSigAlgNameX509Openssl(HcfX509CertificateSpi *self, HcfBlob * int32_t resLen = OBJ_obj2txt(oidStr, OID_STR_MAX_LEN, oidObj, 1); if ((resLen < 0) || (resLen >= OID_STR_MAX_LEN)) { LOGE("Failed to convert x509 object to text!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *algName = GetAlgorithmName(oidStr); @@ -532,7 +528,7 @@ static HcfResult GetSigAlgOidX509Openssl(HcfX509CertificateSpi *self, HcfBlob *o int32_t resLen = OBJ_obj2txt(algOid, OID_STR_MAX_LEN, oid, 1); if ((resLen < 0) || (resLen >= OID_STR_MAX_LEN)) { LOGE("Failed to convert x509 object to text!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } uint32_t len = strlen(algOid) + 1; @@ -565,9 +561,9 @@ static HcfResult GetSigAlgParamsX509Openssl(HcfX509CertificateSpi *self, HcfBlob LOGE("Failed to malloc for asn1 type data!"); return HCF_ERR_MALLOC; } - if (ASN1_TYPE_set1(param, paramType, paramValue) != HCF_OPENSSL_SUCCESS) { + if (ASN1_TYPE_set1(param, paramType, paramValue) != CF_OPENSSL_SUCCESS) { LOGE("Failed to set asn1 type in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); ASN1_TYPE_free(param); return HCF_ERR_CRYPTO_OPERATION; } @@ -575,7 +571,7 @@ static HcfResult GetSigAlgParamsX509Openssl(HcfX509CertificateSpi *self, HcfBlob int32_t len = i2d_ASN1_TYPE(param, NULL); if (len <= 0) { LOGE("Failed to convert ASN1_TYPE!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); ASN1_TYPE_free(param); return HCF_ERR_CRYPTO_OPERATION; } @@ -620,7 +616,7 @@ static HcfResult GetKeyUsageX509Openssl(HcfX509CertificateSpi *self, HcfBlob *bo ASN1_BIT_STRING *keyUsage = (ASN1_BIT_STRING *)X509_get_ext_d2i(x509, NID_key_usage, NULL, NULL); if ((keyUsage == NULL) || (keyUsage->length <= 0)|| (keyUsage->length >= HCF_MAX_STR_LEN)) { LOGE("Failed to get x509 keyUsage in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = ConvertAsn1String2BoolArray(keyUsage, boolArr); @@ -635,7 +631,7 @@ static HcfResult DeepCopyExtendedKeyUsage(const STACK_OF(ASN1_OBJECT) *extUsage, int32_t resLen = OBJ_obj2txt(usage, OID_STR_MAX_LEN, sk_ASN1_OBJECT_value(extUsage, i), 1); if ((resLen < 0) || (resLen >= OID_STR_MAX_LEN)) { LOGE("Failed to convert x509 object to text!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } uint32_t len = strlen(usage) + 1; @@ -644,32 +640,11 @@ static HcfResult DeepCopyExtendedKeyUsage(const STACK_OF(ASN1_OBJECT) *extUsage, LOGE("Failed to malloc for key usage!"); return HCF_ERR_MALLOC; } - if (memcpy_s(keyUsageOut->data[i].data, len, usage, len) != EOK) { - LOGE("Failed to copy the key usage!"); - HcfFree(keyUsageOut->data[i].data); - keyUsageOut->data[i].data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(keyUsageOut->data[i].data, len, usage, len); keyUsageOut->data[i].len = len; return HCF_SUCCESS; } -static void DestroyArray(HcfArray *arr) -{ - if (arr == NULL) { - LOGD("The input array is null, no need to free."); - return; - } - for (uint32_t i = 0; i < arr->count; ++i) { - HcfFree(arr->data[i].data); - arr->data[i].data = NULL; - arr->data[i].len = 0; - } - arr->count = 0; - HcfFree(arr->data); - arr->data = NULL; -} - static HcfResult GetExtendedKeyUsageX509Openssl(HcfX509CertificateSpi *self, HcfArray *keyUsageOut) { if ((self == NULL) || (keyUsageOut == NULL)) { @@ -692,11 +667,10 @@ static HcfResult GetExtendedKeyUsageX509Openssl(HcfX509CertificateSpi *self, Hcf int32_t size = sk_ASN1_OBJECT_num(extUsage); if (size <= 0) { LOGE("The extended key usage size in openssl is invalid!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); res = HCF_ERR_CRYPTO_OPERATION; break; } - keyUsageOut->count = size; int32_t blobSize = sizeof(HcfBlob) * size; keyUsageOut->data = (HcfBlob *)HcfMalloc(blobSize, 0); if (keyUsageOut->data == NULL) { @@ -704,6 +678,7 @@ static HcfResult GetExtendedKeyUsageX509Openssl(HcfX509CertificateSpi *self, Hcf res = HCF_ERR_MALLOC; break; } + keyUsageOut->count = size; for (int32_t i = 0; i < size; ++i) { res = DeepCopyExtendedKeyUsage(extUsage, i, keyUsageOut); if (res != HCF_SUCCESS) { @@ -713,7 +688,7 @@ static HcfResult GetExtendedKeyUsageX509Openssl(HcfX509CertificateSpi *self, Hcf } } while (0); if (res != HCF_SUCCESS) { - DestroyArray(keyUsageOut); + HcfArrayDataClearAndFree(keyUsageOut); } sk_ASN1_OBJECT_pop_free(extUsage, ASN1_OBJECT_free); return res; @@ -761,7 +736,7 @@ static HcfResult DeepCopyAlternativeNames(const STACK_OF(GENERAL_NAME) *altNames const char *str = (const char *)ASN1_STRING_get0_data(ans1Str); if ((str == NULL) || (strlen(str) > HCF_MAX_STR_LEN)) { LOGE("Failed to get x509 altNames string in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } uint32_t nameLen = strlen(str) + 1; @@ -770,12 +745,7 @@ static HcfResult DeepCopyAlternativeNames(const STACK_OF(GENERAL_NAME) *altNames LOGE("Failed to malloc for outName!"); return HCF_ERR_MALLOC; } - if (memcpy_s(outName->data[i].data, nameLen, str, nameLen) != EOK) { - LOGE("Failed to copy the outName!"); - HcfFree(outName->data[i].data); - outName->data[i].data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(outName->data[i].data, nameLen, str, nameLen); outName->data[i].len = nameLen; return HCF_SUCCESS; } @@ -795,7 +765,7 @@ static HcfResult GetSubjectAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfA STACK_OF(GENERAL_NAME) *subjectAltName = X509_get_ext_d2i(x509, NID_subject_alt_name, NULL, NULL); if (subjectAltName == NULL) { LOGE("Failed to get subjectAltName in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = HCF_SUCCESS; @@ -803,11 +773,10 @@ static HcfResult GetSubjectAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfA int32_t size = sk_GENERAL_NAME_num(subjectAltName); if (size <= 0) { LOGE("The subjectAltName number in openssl is invalid!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); res = HCF_ERR_CRYPTO_OPERATION; break; } - outName->count = size; int32_t blobSize = sizeof(HcfBlob) * size; outName->data = (HcfBlob *)HcfMalloc(blobSize, 0); if (outName->data == NULL) { @@ -815,6 +784,7 @@ static HcfResult GetSubjectAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfA res = HCF_ERR_MALLOC; break; } + outName->count = size; for (int32_t i = 0; i < size; ++i) { res = DeepCopyAlternativeNames(subjectAltName, i, outName); if (res != HCF_SUCCESS) { @@ -824,7 +794,7 @@ static HcfResult GetSubjectAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfA } } while (0); if (res != HCF_SUCCESS) { - DestroyArray(outName); + HcfArrayDataClearAndFree(outName); } GENERAL_NAMES_free(subjectAltName); return res; @@ -845,7 +815,7 @@ static HcfResult GetIssuerAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfAr STACK_OF(GENERAL_NAME) *issuerAltName = X509_get_ext_d2i(x509, NID_issuer_alt_name, NULL, NULL); if (issuerAltName == NULL) { LOGE("Failed to get issuerAltName in openssl!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = HCF_SUCCESS; @@ -853,11 +823,10 @@ static HcfResult GetIssuerAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfAr int32_t size = sk_GENERAL_NAME_num(issuerAltName); if (size <= 0) { LOGE("The issuerAltName number in openssl is invalid!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); res = HCF_ERR_CRYPTO_OPERATION; break; } - outName->count = size; int32_t blobSize = sizeof(HcfBlob) * size; outName->data = (HcfBlob *)HcfMalloc(blobSize, 0); if (outName->data == NULL) { @@ -865,6 +834,7 @@ static HcfResult GetIssuerAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfAr res = HCF_ERR_MALLOC; break; } + outName->count = size; for (int32_t i = 0; i < size; ++i) { res = DeepCopyAlternativeNames(issuerAltName, i, outName); if (res != HCF_SUCCESS) { @@ -874,7 +844,7 @@ static HcfResult GetIssuerAltNamesX509Openssl(HcfX509CertificateSpi *self, HcfAr } } while (0); if (res != HCF_SUCCESS) { - DestroyArray(outName); + HcfArrayDataClearAndFree(outName); } GENERAL_NAMES_free(issuerAltName); return res; diff --git a/plugin/openssl_plugin/certificate/src/x509_crl_entry_openssl.c b/plugin/openssl_plugin/certificate/src/x509_crl_entry_openssl.c index d09f2cfc0b8fe07f2e518090d77bbad14e1f9eae..4daec8326f93528ae32c77c720078bd1851b956e 100644 --- a/plugin/openssl_plugin/certificate/src/x509_crl_entry_openssl.c +++ b/plugin/openssl_plugin/certificate/src/x509_crl_entry_openssl.c @@ -24,7 +24,7 @@ #include "hcf_string.h" #include "log.h" #include "memory.h" -#include "openssl_common.h" +#include "certificate_openssl_common.h" #include "utils.h" #include "x509_crl.h" #include "x509_crl_entry.h" @@ -67,7 +67,7 @@ static HcfResult GetEncoded(HcfX509CrlEntry *self, HcfEncodingBlob *encodedOut) int32_t length = i2d_X509_REVOKED(rev, &out); if (length <= 0) { LOGE("Do i2d_X509_REVOKED fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } encodedOut->data = (uint8_t *)HcfMalloc(length, 0); @@ -76,37 +76,49 @@ static HcfResult GetEncoded(HcfX509CrlEntry *self, HcfEncodingBlob *encodedOut) OPENSSL_free(out); return HCF_ERR_MALLOC; } - if (memcpy_s(encodedOut->data, length, out, length) != EOK) { - LOGE("Failed to copy the encodedOut!"); - HcfFree(encodedOut->data); - encodedOut->data = NULL; - OPENSSL_free(out); - return HCF_ERR_COPY; - } + (void)memcpy_s(encodedOut->data, length, out, length); encodedOut->len = length; encodedOut->encodingFormat = HCF_FORMAT_DER; OPENSSL_free(out); return HCF_SUCCESS; } -static long GetSerialNumber(HcfX509CrlEntry *self) +static HcfResult GetSerialNumber(HcfX509CrlEntry *self, HcfBlob *out) { if (self == NULL) { LOGE("Invalid Paramas for calling GetSerialNumber!"); - return OPENSSL_ERROR_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } X509_REVOKED *rev = GetSelfRev(self); if (rev == NULL) { LOGE("Rev is null!"); - return OPENSSL_ERROR_SERIAL_NUMBER; + return HCF_INVALID_PARAMS; } const ASN1_INTEGER *serialNumber = X509_REVOKED_get0_serialNumber(rev); if (serialNumber == NULL) { LOGE("Get serial number fail!"); - HcfPrintOpensslError(); - return OPENSSL_ERROR_SERIAL_NUMBER; + CfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + unsigned char *serialNumBytes = NULL; + int serialNumLen = i2d_ASN1_INTEGER((ASN1_INTEGER *)serialNumber, &serialNumBytes); + if (serialNumLen <= SERIAL_NUMBER_HEDER_SIZE) { + CfPrintOpensslError(); + LOGE("get serial num len failed!"); + return HCF_ERR_CRYPTO_OPERATION; + } + + out->data = (uint8_t *)HcfMalloc(serialNumLen - SERIAL_NUMBER_HEDER_SIZE, 0); + if (out->data == NULL) { + OPENSSL_free(&serialNumBytes); + LOGE("Failed to malloc serial num"); + return HCF_ERR_MALLOC; } - return ASN1_INTEGER_get(serialNumber); + out->len = serialNumLen - SERIAL_NUMBER_HEDER_SIZE; + (void)memcpy_s(out->data, out->len, serialNumBytes + SERIAL_NUMBER_HEDER_SIZE, out->len); + OPENSSL_free(serialNumBytes); + return HCF_SUCCESS; } static HcfResult GetCertIssuer(HcfX509CrlEntry *self, HcfBlob *encodedOut) @@ -130,12 +142,7 @@ static HcfResult GetCertIssuer(HcfX509CrlEntry *self, HcfBlob *encodedOut) LOGE("Failed to malloc for encodedOut!"); return HCF_ERR_MALLOC; } - if (memcpy_s(encodedOut->data, length, certIssuer->data, length) != EOK) { - LOGE("Failed to copy the encodedOut!"); - HcfFree(encodedOut->data); - encodedOut->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(encodedOut->data, length, certIssuer->data, length); encodedOut->len = length; return HCF_SUCCESS; } @@ -154,7 +161,7 @@ static HcfResult GetRevocationDate(HcfX509CrlEntry *self, HcfBlob *out) const ASN1_TIME *time = X509_REVOKED_get0_revocationDate(rev); if (time == NULL) { LOGE("Get revocation date fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *revTime = (const char *)(time->data); @@ -168,12 +175,7 @@ static HcfResult GetRevocationDate(HcfX509CrlEntry *self, HcfBlob *out) LOGE("Failed to malloc for revTime!"); return HCF_ERR_MALLOC; } - if (memcpy_s(out->data, length, revTime, length) != EOK) { - LOGE("Failed to copy the revTime!"); - HcfFree(out->data); - out->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(out->data, length, revTime, length); out->len = length; return HCF_SUCCESS; } @@ -192,14 +194,7 @@ static HcfResult DeepCopyCertIssuer(HcfX509CRLEntryOpensslImpl *returnCRLEntry, LOGE("Failed to malloc certIssuer data!"); return HCF_ERR_MALLOC; } - if (memcpy_s(returnCRLEntry->certIssuer->data, len, certIssuer->data, len) != EOK) { - LOGE("Failed to copy the certIssuer data!"); - HcfFree(returnCRLEntry->certIssuer->data); - returnCRLEntry->certIssuer->data = NULL; - HcfFree(returnCRLEntry->certIssuer); - returnCRLEntry->certIssuer = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(returnCRLEntry->certIssuer->data, len, certIssuer->data, len); return HCF_SUCCESS; } @@ -214,7 +209,10 @@ static void Destroy(HcfObjectBase *self) return; } HcfX509CRLEntryOpensslImpl *realCrlEntry = (HcfX509CRLEntryOpensslImpl *)self; - realCrlEntry->rev = NULL; + if (realCrlEntry->rev != NULL) { + X509_REVOKED_free(realCrlEntry->rev); + realCrlEntry->rev = NULL; + } if (realCrlEntry->certIssuer != NULL) { HcfFree(realCrlEntry->certIssuer->data); realCrlEntry->certIssuer->data = NULL; @@ -236,7 +234,14 @@ HcfResult HcfCX509CRLEntryCreate(X509_REVOKED *rev, HcfX509CrlEntry **crlEntryOu LOGE("Failed to malloc for x509 entry instance!"); return HCF_ERR_MALLOC; } - returnCRLEntry->rev = rev; + + X509_REVOKED *tmp = X509_REVOKED_dup(rev); + if (tmp == NULL) { + HcfFree(returnCRLEntry); + LOGE("Failed to dup x509 revoked"); + return HCF_ERR_MALLOC; + } + returnCRLEntry->rev = tmp; returnCRLEntry->certIssuer = NULL; returnCRLEntry->base.base.getClass = GetClass; returnCRLEntry->base.base.destroy = Destroy; diff --git a/plugin/openssl_plugin/certificate/src/x509_crl_openssl.c b/plugin/openssl_plugin/certificate/src/x509_crl_openssl.c index ea4764dc444fa93aac58579a781e598e44d65072..fe21bc5d457c96bba143b1a42c28c1de0572718d 100644 --- a/plugin/openssl_plugin/certificate/src/x509_crl_openssl.c +++ b/plugin/openssl_plugin/certificate/src/x509_crl_openssl.c @@ -29,8 +29,8 @@ #include "hcf_string.h" #include "log.h" #include "memory.h" -#include "openssl_class.h" -#include "openssl_common.h" +#include "certificate_openssl_class.h" +#include "certificate_openssl_common.h" #include "utils.h" #include "x509_crl.h" #include "x509_crl_entry_openssl.h" @@ -135,7 +135,7 @@ static HcfResult GetEncoded(HcfX509CrlSpi *self, HcfEncodingBlob *encodedOut) int32_t length = i2d_X509_CRL(crl, &out); if (length <= 0) { LOGE("Do i2d_X509_CRL fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } encodedOut->data = (uint8_t *)HcfMalloc(length, 0); @@ -144,13 +144,7 @@ static HcfResult GetEncoded(HcfX509CrlSpi *self, HcfEncodingBlob *encodedOut) OPENSSL_free(out); return HCF_ERR_MALLOC; } - if (memcpy_s(encodedOut->data, length, out, length) != EOK) { - LOGE("Failed to copy the x509 encoded data!"); - OPENSSL_free(out); - HcfFree(encodedOut->data); - encodedOut->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(encodedOut->data, length, out, length); OPENSSL_free(out); encodedOut->len = length; encodedOut->encodingFormat = HCF_FORMAT_DER; @@ -176,12 +170,12 @@ static HcfResult Verify(HcfX509CrlSpi *self, HcfPubKey *key) EVP_PKEY *pubKey = EVP_PKEY_new(); if (pubKey == NULL) { LOGE("pubKey is null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } if (EVP_PKEY_assign_RSA(pubKey, rsaPubkey) <= 0) { LOGE("Do EVP_PKEY_assign_RSA fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } X509_CRL *crl = ((HcfX509CRLOpensslImpl *)self)->crl; @@ -190,9 +184,9 @@ static HcfResult Verify(HcfX509CrlSpi *self, HcfPubKey *key) return HCF_INVALID_PARAMS; } int32_t res = X509_CRL_verify(crl, pubKey); - if (res != HCF_OPENSSL_SUCCESS) { + if (res != CF_OPENSSL_SUCCESS) { LOGE("Verify fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } return HCF_SUCCESS; @@ -230,13 +224,13 @@ static HcfResult GetIssuerName(HcfX509CrlSpi *self, HcfBlob *out) X509_NAME *x509Name = X509_CRL_get_issuer(crl); if (x509Name == NULL) { LOGE("Get Issuer DN fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *issuer = X509_NAME_oneline(x509Name, NULL, 0); if ((issuer == NULL) || (strlen(issuer) > HCF_MAX_STR_LEN)) { LOGE("X509Name convert char fail or issuer name is too long!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } uint32_t length = strlen(issuer) + 1; @@ -245,12 +239,7 @@ static HcfResult GetIssuerName(HcfX509CrlSpi *self, HcfBlob *out) LOGE("Failed to malloc for crl issuer data!"); return HCF_ERR_MALLOC; } - if (memcpy_s(out->data, length, issuer, length) != EOK) { - LOGE("Failed to copy the x509 issuer data!"); - HcfFree(out->data); - out->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(out->data, length, issuer, length); out->len = length; return HCF_SUCCESS; } @@ -284,7 +273,7 @@ static HcfResult GetLastUpdate(HcfX509CrlSpi *self, HcfBlob *out) const ASN1_TIME *time = X509_CRL_get0_lastUpdate(crl); if (time == NULL) { LOGE("Get this update time fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *thisUpdate = (const char *)(time->data); @@ -298,12 +287,7 @@ static HcfResult GetLastUpdate(HcfX509CrlSpi *self, HcfBlob *out) LOGE("Failed to malloc for thisUpdate!"); return HCF_ERR_MALLOC; } - if (memcpy_s(out->data, length, thisUpdate, length) != EOK) { - LOGE("Failed to copy the thisUpdate!"); - HcfFree(out->data); - out->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(out->data, length, thisUpdate, length); out->len = length; return HCF_SUCCESS; } @@ -322,7 +306,7 @@ static HcfResult GetNextUpdate(HcfX509CrlSpi *self, HcfBlob *out) const ASN1_TIME *time = X509_CRL_get0_nextUpdate(crl); if (time == NULL) { LOGE("Get next update time fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const char *nextUpdate = (const char *)(time->data); @@ -336,12 +320,7 @@ static HcfResult GetNextUpdate(HcfX509CrlSpi *self, HcfBlob *out) LOGE("Failed to malloc for nextUpdate!"); return HCF_ERR_MALLOC; } - if (memcpy_s(out->data, length, nextUpdate, length) != EOK) { - LOGE("Failed to copy the nextUpdate!"); - HcfFree(out->data); - out->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(out->data, length, nextUpdate, length); out->len = length; return HCF_SUCCESS; } @@ -360,27 +339,26 @@ static HcfResult GetRevokedCert(HcfX509CrlSpi *self, long serialNumber, HcfX509C ASN1_INTEGER *serial = ASN1_INTEGER_new(); if (serial == NULL) { LOGE("Serial init fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } if (!ASN1_INTEGER_set(serial, serialNumber)) { LOGE("Set serial number fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); ASN1_INTEGER_free(serial); return HCF_ERR_CRYPTO_OPERATION; } X509_REVOKED *rev = NULL; int32_t opensslRes = X509_CRL_get0_by_serial(crl, &rev, serial); ASN1_INTEGER_free(serial); - if (opensslRes != HCF_OPENSSL_SUCCESS) { + if (opensslRes != CF_OPENSSL_SUCCESS) { LOGE("Get revoked certificate fail, res : %d!", opensslRes); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = HcfCX509CRLEntryCreate(rev, entryOut, ((HcfX509CRLOpensslImpl *)self)->certIssuer); if (res != HCF_SUCCESS) { LOGE("X509 CRL entry create fail, res : %d!", res); - X509_REVOKED_free(rev); return res; } return HCF_SUCCESS; @@ -409,15 +387,14 @@ static HcfResult GetRevokedCertWithCert(HcfX509CrlSpi *self, HcfX509Certificate } X509_REVOKED *revokedRet = NULL; int32_t opensslRes = X509_CRL_get0_by_cert(crl, &revokedRet, certOpenssl); - if (opensslRes != HCF_OPENSSL_SUCCESS) { + if (opensslRes != CF_OPENSSL_SUCCESS) { LOGE("Get revoked certificate with cert fail, res : %d!", opensslRes); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfResult res = HcfCX509CRLEntryCreate(revokedRet, entryOut, ((HcfX509CRLOpensslImpl *)self)->certIssuer); if (res != HCF_SUCCESS) { LOGE("X509 CRL entry create fail, res : %d!", res); - X509_REVOKED_free(revokedRet); return res; } return HCF_SUCCESS; @@ -429,7 +406,7 @@ static HcfResult DeepCopyRevokedCertificates(HcfX509CrlSpi *self, const STACK_OF X509_REVOKED *rev = sk_X509_REVOKED_value(entrys, i); if (rev == NULL) { LOGE("sk_X509_REVOKED_value fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } HcfX509CrlEntry *crlEntry = NULL; @@ -476,13 +453,13 @@ static HcfResult GetRevokedCerts(HcfX509CrlSpi *self, HcfArray *entrysOut) STACK_OF(X509_REVOKED) *entrys = X509_CRL_get_REVOKED(crl); if (entrys == NULL) { LOGE("Get revoked certificates fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } int32_t revokedNum = sk_X509_REVOKED_num(entrys); if ((revokedNum <= 0) || (revokedNum > MAX_REV_NUM)) { LOGE("Get revoked invalid number!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } uint32_t blobSize = sizeof(HcfBlob) * revokedNum; @@ -517,7 +494,7 @@ static HcfResult GetTbsList(HcfX509CrlSpi *self, HcfBlob *tbsCertListOut) int32_t length = i2d_re_X509_CRL_tbs(crl, &tbs); if ((length <= 0) || (tbs == NULL)) { LOGE("Get TBS certList fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } tbsCertListOut->data = (uint8_t *)HcfMalloc(length, 0); @@ -526,13 +503,7 @@ static HcfResult GetTbsList(HcfX509CrlSpi *self, HcfBlob *tbsCertListOut) OPENSSL_free(tbs); return HCF_ERR_MALLOC; } - if (memcpy_s(tbsCertListOut->data, length, tbs, length) != EOK) { - LOGE("Failed to copy the tbs!"); - HcfFree(tbsCertListOut->data); - tbsCertListOut->data = NULL; - OPENSSL_free(tbs); - return HCF_ERR_COPY; - } + (void)memcpy_s(tbsCertListOut->data, length, tbs, length); OPENSSL_free(tbs); tbsCertListOut->len = length; return HCF_SUCCESS; @@ -549,23 +520,23 @@ static HcfResult GetSignature(HcfX509CrlSpi *self, HcfBlob *signature) LOGE("crl is null!"); return HCF_INVALID_PARAMS; } - const ASN1_BIT_STRING *Asn1Signature = NULL; - X509_CRL_get0_signature(((HcfX509CRLOpensslImpl *)self)->crl, &Asn1Signature, NULL); - if (Asn1Signature == NULL) { + const ASN1_BIT_STRING *asn1Signature = NULL; + X509_CRL_get0_signature(((HcfX509CRLOpensslImpl *)self)->crl, &asn1Signature, NULL); + if (asn1Signature == NULL) { LOGE("Get signature is null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - int32_t signatureLen = ASN1_STRING_length(Asn1Signature); + int32_t signatureLen = ASN1_STRING_length(asn1Signature); if (signatureLen <= 0) { LOGE("Get signature length is invalid!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - const unsigned char *signatureStr = ASN1_STRING_get0_data(Asn1Signature); + const unsigned char *signatureStr = ASN1_STRING_get0_data(asn1Signature); if ((signatureStr == NULL) || (signatureLen > MAX_SIGNATURE_LEN)) { LOGE("ASN1 get string fail, or signature length is too long!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } signature->data = (uint8_t *)HcfMalloc(signatureLen, 0); @@ -573,30 +544,25 @@ static HcfResult GetSignature(HcfX509CrlSpi *self, HcfBlob *signature) LOGE("Failed to malloc for signature!"); return HCF_ERR_MALLOC; } - if (memcpy_s(signature->data, signatureLen, signatureStr, signatureLen) != EOK) { - LOGE("Failed to copy the signature!"); - HcfFree(signature->data); - signature->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(signature->data, signatureLen, signatureStr, signatureLen); signature->len = signatureLen; return HCF_SUCCESS; } -static HcfResult getSignatureAlgOidInner(X509_CRL *crl, HcfBlob *oidOut) +static HcfResult GetSignatureAlgOidInner(X509_CRL *crl, HcfBlob *oidOut) { const X509_ALGOR *palg = NULL; X509_CRL_get0_signature(crl, NULL, &palg); if (palg == NULL) { LOGE("alg is null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } const ASN1_OBJECT *oid = NULL; X509_ALGOR_get0(&oid, NULL, NULL, palg); if (oid == NULL) { LOGE("oid is null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } char *output = (char *)HcfMalloc(OID_LENGTH, 0); @@ -607,7 +573,7 @@ static HcfResult getSignatureAlgOidInner(X509_CRL *crl, HcfBlob *oidOut) int32_t resLen = OBJ_obj2txt(output, OID_LENGTH, oid, 1); if (resLen < 0) { LOGE("Failed to do OBJ_obj2txt!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); HcfFree(output); return HCF_ERR_CRYPTO_OPERATION; } @@ -618,19 +584,13 @@ static HcfResult getSignatureAlgOidInner(X509_CRL *crl, HcfBlob *oidOut) HcfFree(output); return HCF_ERR_MALLOC; } - if (memcpy_s(oidOut->data, length, output, length) != EOK) { - LOGE("Failed to copy the oidOut!"); - HcfFree(oidOut->data); - oidOut->data = NULL; - HcfFree(output); - return HCF_ERR_COPY; - } + (void)memcpy_s(oidOut->data, length, output, length); HcfFree(output); oidOut->len = length; return HCF_SUCCESS; } -static HcfResult getSignatureAlgOid(HcfX509CrlSpi *self, HcfBlob *oidOut) +static HcfResult GetSignatureAlgOid(HcfX509CrlSpi *self, HcfBlob *oidOut) { if ((self == NULL) || (oidOut == NULL)) { LOGE("Invalid Paramas!"); @@ -641,7 +601,7 @@ static HcfResult getSignatureAlgOid(HcfX509CrlSpi *self, HcfBlob *oidOut) LOGE("crl is null!"); return HCF_INVALID_PARAMS; } - return getSignatureAlgOidInner(crl, oidOut); + return GetSignatureAlgOidInner(crl, oidOut); } static HcfResult GetSignatureAlgName(HcfX509CrlSpi *self, HcfBlob *algNameOut) @@ -655,7 +615,7 @@ static HcfResult GetSignatureAlgName(HcfX509CrlSpi *self, HcfBlob *algNameOut) return HCF_INVALID_PARAMS; } HcfBlob *oidOut = (HcfBlob *)HcfMalloc(sizeof(HcfBlob), 0); - HcfResult res = getSignatureAlgOid(self, oidOut); + HcfResult res = GetSignatureAlgOid(self, oidOut); if (res != HCF_SUCCESS) { LOGE("Get signature algor oid failed!"); HcfFree(oidOut); @@ -674,12 +634,7 @@ static HcfResult GetSignatureAlgName(HcfX509CrlSpi *self, HcfBlob *algNameOut) LOGE("Failed to malloc for algName!"); return HCF_ERR_MALLOC; } - if (memcpy_s(algNameOut->data, length, algName, length) != EOK) { - LOGE("Failed to copy the algName!"); - HcfFree(algNameOut->data); - algNameOut->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(algNameOut->data, length, algName, length); algNameOut->len = length; return HCF_SUCCESS; } @@ -690,7 +645,7 @@ static HcfResult GetSignatureAlgParamsInner(X509_CRL *crl, HcfBlob *sigAlgParamO X509_CRL_get0_signature(crl, NULL, &palg); if (palg == NULL) { LOGE("Get alg is null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } int32_t paramType = 0; @@ -698,14 +653,14 @@ static HcfResult GetSignatureAlgParamsInner(X509_CRL *crl, HcfBlob *sigAlgParamO X509_ALGOR_get0(NULL, ¶mType, ¶mValue, palg); if (paramType == V_ASN1_UNDEF) { LOGE("get_X509_ALGOR_parameter, no parameters!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_NOT_SUPPORT; } ASN1_TYPE *param = ASN1_TYPE_new(); - if (ASN1_TYPE_set1(param, paramType, paramValue) != HCF_OPENSSL_SUCCESS) { + if (ASN1_TYPE_set1(param, paramType, paramValue) != CF_OPENSSL_SUCCESS) { LOGE("Set type fail!"); ASN1_TYPE_free(param); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } unsigned char *outParams = NULL; @@ -713,7 +668,7 @@ static HcfResult GetSignatureAlgParamsInner(X509_CRL *crl, HcfBlob *sigAlgParamO ASN1_TYPE_free(param); if (length <= 0) { LOGE("Do i2d_ASN1_TYPE fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } sigAlgParamOut->data = (uint8_t *)HcfMalloc(length, 0); @@ -722,13 +677,7 @@ static HcfResult GetSignatureAlgParamsInner(X509_CRL *crl, HcfBlob *sigAlgParamO OPENSSL_free(outParams); return HCF_ERR_MALLOC; } - if (memcpy_s(sigAlgParamOut->data, length, outParams, length) != EOK) { - LOGE("Failed to copy the sigAlgParamOut!"); - HcfFree(sigAlgParamOut->data); - sigAlgParamOut->data = NULL; - OPENSSL_free(outParams); - return HCF_ERR_COPY; - } + (void)memcpy_s(sigAlgParamOut->data, length, outParams, length); sigAlgParamOut->len = length; OPENSSL_free(outParams); return HCF_SUCCESS; @@ -778,7 +727,7 @@ static X509_CRL *ParseX509CRL(const HcfEncodingBlob *inStream) BIO *bio = BIO_new_mem_buf(inStream->data, inStream->len); if (bio == NULL) { LOGE("bio get null!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return NULL; } X509_CRL *crlOut = NULL; @@ -793,9 +742,10 @@ static X509_CRL *ParseX509CRL(const HcfEncodingBlob *inStream) LOGE("Not support format!"); break; } + BIO_free_all(bio); if (crlOut == NULL) { LOGE("Parse X509 CRL fail!"); - HcfPrintOpensslError(); + CfPrintOpensslError(); return NULL; } return crlOut; @@ -836,7 +786,7 @@ HcfResult HcfCX509CrlSpiCreate(const HcfEncodingBlob *inStream, HcfX509CrlSpi ** returnCRL->base.engineGetTbsInfo = GetTbsList; returnCRL->base.engineGetSignature = GetSignature; returnCRL->base.engineGetSignatureAlgName = GetSignatureAlgName; - returnCRL->base.engineGetSignatureAlgOid = getSignatureAlgOid; + returnCRL->base.engineGetSignatureAlgOid = GetSignatureAlgOid; returnCRL->base.engineGetSignatureAlgParams = GetSignatureAlgParams; if (SetCertIssuer((HcfX509CrlSpi *)returnCRL) != HCF_SUCCESS) { LOGI("No cert issuer find or set cert issuer fail!"); diff --git a/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl_common.h b/plugin/openssl_plugin/common/inc/aes_openssl_common.h similarity index 59% rename from plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl_common.h rename to plugin/openssl_plugin/common/inc/aes_openssl_common.h index e64407ec2cfb76c0995e673a4a858e08e013bd04..be339aa60a229dae89ee919f3165b03ce4d9671e 100644 --- a/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl_common.h +++ b/plugin/openssl_plugin/common/inc/aes_openssl_common.h @@ -13,49 +13,44 @@ * limitations under the License. */ -/* - * Copyright (C) 2022 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_AES_OPENSSL_COMMON_H #define HCF_AES_OPENSSL_COMMON_H +#include +#include +#include "aes_openssl.h" #include "detailed_iv_params.h" #include "detailed_ccm_params.h" #include "detailed_gcm_params.h" - -#include "aes_openssl.h" - -#include +typedef struct { + EVP_CIPHER_CTX *ctx; + enum HcfCryptoMode enc; + /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE need AEAD */ + bool aead; + uint32_t updateLen; + unsigned char *iv; + uint32_t ivLen; + /* GCM, CCM only */ + unsigned char *aad; + uint32_t aadLen; + unsigned char *tag; + uint32_t tagLen; +} CipherData; #ifdef __cplusplus extern "C" { #endif const unsigned char *GetIv(HcfParamsSpec *params); -int32_t GetIvLen(HcfParamsSpec *params); - -int32_t GetGcmTagLen(HcfParamsSpec *params); - int32_t GetCcmTagLen(HcfParamsSpec *params); -void *GetGcmTag(HcfParamsSpec *params); - void *GetCcmTag(HcfParamsSpec *params); void FreeCipherData(CipherData **data); +void FreeRedundantOutput(HcfBlob *blob); + #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..cd066e89dd7d549f365249b781375bbaf08708b5 --- /dev/null +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2022 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_OPENSSL_ADAPTER_H +#define HCF_OPENSSL_ADAPTER_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +BIGNUM *Openssl_BN_dup(const BIGNUM *a); +void Openssl_BN_clear(BIGNUM *a); +void Openssl_BN_clear_free(BIGNUM *a); + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid); +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); +int Openssl_EC_KEY_generate_key(EC_KEY *eckey); +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key); +int Openssl_EC_KEY_check_key(const EC_KEY *key); +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key); +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key); +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key); +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp); +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length); +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag); +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags); +void Openssl_EC_KEY_free(EC_KEY *key); +void Openssl_EC_POINT_free(EC_POINT *point); + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void); +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx); +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count); +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen); +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count); +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen); + +EVP_PKEY *Openssl_EVP_PKEY_new(void); +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key); +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey); + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/plugin/openssl_plugin/common/inc/openssl_class.h b/plugin/openssl_plugin/common/inc/openssl_class.h index 818e451837de5479e877a93f1ea2085f3af73936..2469b915513eb8c661eee303db2d7689f7a529cc 100644 --- a/plugin/openssl_plugin/common/inc/openssl_class.h +++ b/plugin/openssl_plugin/common/inc/openssl_class.h @@ -19,16 +19,11 @@ #include "pub_key.h" #include "pri_key.h" #include "key_pair.h" -#include "x509_certificate_spi.h" -#include "x509_crl_entry.h" -#include "x509_crl.h" -#include "x509_crl_spi.h" #include #include #include #include -#include typedef struct { HcfPubKey base; @@ -76,26 +71,6 @@ typedef struct { } HcfOpensslRsaKeyPair; #define OPENSSL_RSA_KEYPAIR_CLASS "OPENSSL.RSA.KEY_PAIR" -typedef struct { - HcfX509CertificateSpi base; - X509 *x509; -} HcfOpensslX509Cert; -#define X509_CERT_OPENSSL_CLASS "X509CertOpensslClass" - -typedef struct { - HcfX509CrlEntry base; - X509_REVOKED *rev; - HcfBlob *certIssuer; -} HcfX509CRLEntryOpensslImpl; -#define X509_CRL_ENTRY_OPENSSL_CLASS "X509CrlEntryOpensslClass" - -typedef struct { - HcfX509Crl base; - HcfX509CrlSpi *spiObj; - const char *certType; -} HcfX509CrlImpl; -#define X509_CRL_OPENSSL_CLASS "X509CrlOpensslClass" - #define OPENSSL_RSA_CIPHER_CLASS "OPENSSL.RSA.CIPHER" #define OPENSSL_3DES_CIPHER_CLASS "OPENSSL.3DES.CIPHER" #define OPENSSL_AES_CIPHER_CLASS "OPENSSL.AES.CIPHER" diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index 0ac660decaae03278a5862b59b590e383ac3aaac..e88f37db99b6f858193d45d4b2eb08fa2dd94a06 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -29,7 +29,6 @@ extern "C" { #endif -const char *GetAlgorithmName(const char *oid); int32_t GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId); const EVP_MD *GetOpensslDigestAlg(uint32_t alg); void HcfPrintOpensslError(void); diff --git a/plugin/openssl_plugin/common/inc/rsa_openssl_common.h b/plugin/openssl_plugin/common/inc/rsa_openssl_common.h index 009c762b37e3ea351d2530920c660e30b862a6f8..925c3df010b137764aa5ff192ca26ef2d04cc3e6 100644 --- a/plugin/openssl_plugin/common/inc/rsa_openssl_common.h +++ b/plugin/openssl_plugin/common/inc/rsa_openssl_common.h @@ -16,6 +16,7 @@ #ifndef HCF_RSA_OPENSSL_COMMON_H #define HCF_RSA_OPENSSL_COMMON_H +#include "openssl/evp.h" #include "openssl/rsa.h" #include "result.h" #include "stdbool.h" @@ -29,7 +30,9 @@ typedef enum { extern "C" { #endif -HcfResult DuplicateRsa(const RSA *rsa, bool needPrivate, RSA **dupRsa); +HcfResult DuplicateRsa(RSA *rsa, bool needPrivate, RSA **dupRsa); + +EVP_PKEY *NewEvpPkeyByRsa(RSA *rsa, bool withDuplicate); #ifdef __cplusplus } diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c new file mode 100644 index 0000000000000000000000000000000000000000..4d0b40c2e10dee8ae547280a973a518bd4744e43 --- /dev/null +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_adapter.h" + +#include "log.h" +#include "result.h" + +BIGNUM *Openssl_BN_dup(const BIGNUM *a) +{ + return BN_dup(a); +} + +void Openssl_BN_clear(BIGNUM *a) +{ + BN_clear(a); +} + +void Openssl_BN_clear_free(BIGNUM *a) +{ + BN_clear_free(a); +} + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid) +{ + return EC_KEY_new_by_curve_name(nid); +} + +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group) +{ + return EC_POINT_dup(src, group); +} + +int Openssl_EC_KEY_generate_key(EC_KEY *eckey) +{ + return EC_KEY_generate_key(eckey); +} + +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub) +{ + return EC_KEY_set_public_key(key, pub); +} + +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key) +{ + return EC_KEY_set_private_key(key, priv_key); +} + +int Openssl_EC_KEY_check_key(const EC_KEY *key) +{ + return EC_KEY_check_key(key); +} + +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key) +{ + return EC_KEY_get0_public_key(key); +} + +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key) +{ + return EC_KEY_get0_private_key(key); +} + +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key) +{ + return EC_KEY_get0_group(key); +} + +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp) +{ + return i2d_EC_PUBKEY(a, pp); +} + +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out) +{ + return i2d_ECPrivateKey(key, out); +} + +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) +{ + return d2i_EC_PUBKEY(a, pp, length); +} + +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len) +{ + return d2i_ECPrivateKey(key, in, len); +} + +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag) +{ + EC_KEY_set_asn1_flag(key, flag); +} + +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags) +{ + EC_KEY_set_enc_flags(eckey, flags); +} + +void Openssl_EC_KEY_free(EC_KEY *key) +{ + EC_KEY_free(key); +} + +void Openssl_EC_POINT_free(EC_POINT *point) +{ + EC_POINT_free(point); +} + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void) +{ + return EVP_MD_CTX_new(); +} + +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx) +{ + EVP_MD_CTX_free(ctx); +} + +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + return EVP_DigestSignInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + return EVP_DigestSignUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen) +{ + return EVP_DigestSignFinal(ctx, sigret, siglen); +} + +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + return EVP_DigestVerifyInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + return EVP_DigestVerifyUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen) +{ + return EVP_DigestVerifyFinal(ctx, sig, siglen); +} + +EVP_PKEY *Openssl_EVP_PKEY_new(void) +{ + return EVP_PKEY_new(); +} + +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) +{ + return EVP_PKEY_assign_EC_KEY(pkey, key); +} + +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey) +{ + EVP_PKEY_free(pkey); +} + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) +{ + return EVP_PKEY_CTX_new(pkey, e); +} + +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx) +{ + return EVP_PKEY_derive_init(ctx); +} + +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer) +{ + return EVP_PKEY_derive_set_peer(ctx, peer); +} + +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen) +{ + return EVP_PKEY_derive(ctx, key, keylen); +} + +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) +{ + EVP_PKEY_CTX_free(ctx); +} \ No newline at end of file diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 6dbc36e5be5f10366cb47e0056b1213ac9224801..167ce50baa2c2a1c0244ff8e1a05329f2640158e 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -27,44 +27,6 @@ #define PRIMES_4 4 #define PRIMES_5 5 -typedef struct { - char *oid; - char *algorithmName; -} OidToAlgorithmName; - -static const OidToAlgorithmName OID_TO_NAME_MAP[] = { - { "1.2.840.113549.1.1.2", "MD2withRSA" }, - { "1.2.840.113549.1.1.4", "MD5withRSA" }, - { "1.2.840.113549.1.1.5", "SHA1withRSA" }, - { "1.2.840.10040.4.3", "SHA1withDSA" }, - { "1.2.840.10045.4.1", "SHA1withECDSA" }, - { "1.2.840.113549.1.1.14", "SHA224withRSA" }, - { "1.2.840.113549.1.1.11", "SHA256withRSA" }, - { "1.2.840.113549.1.1.12", "SHA384withRSA" }, - { "1.2.840.113549.1.1.13", "SHA512withRSA" }, - { "2.16.840.1.101.3.4.3.1", "SHA224withDSA" }, - { "2.16.840.1.101.3.4.3.2", "SHA256withDSA" }, - { "1.2.840.10045.4.3.1", "SHA224withECDSA" }, - { "1.2.840.10045.4.3.2", "SHA256withECDSA" }, - { "1.2.840.10045.4.3.3", "SHA384withECDSA" }, - { "1.2.840.10045.4.3.4", "SHA512withECDSA" } -}; - -const char *GetAlgorithmName(const char *oid) -{ - if (oid == NULL) { - LOGE("Oid is null!"); - return NULL; - } - for (uint32_t i = 0; i < sizeof(OID_TO_NAME_MAP); i++) { - if (strcmp(OID_TO_NAME_MAP[i].oid, oid) == 0) { - return OID_TO_NAME_MAP[i].algorithmName; - } - } - LOGE("Can not find algorithmName! [oid]: %s", oid); - return NULL; -} - int32_t GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId) { switch (keyLen) { @@ -77,7 +39,7 @@ int32_t GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId) case HCF_ALG_ECC_384: *returnCurveId = NID_secp384r1; break; - case HCF_ALG_ECC_512: + case HCF_ALG_ECC_521: *returnCurveId = NID_secp521r1; break; default: diff --git a/plugin/openssl_plugin/common/src/rsa_openssl_common.c b/plugin/openssl_plugin/common/src/rsa_openssl_common.c index 7fad10e0afaa07196aa4d30e3fbb086bbbf5f6fb..1a9e0b5f1158e85be1f02af408e5a32b6be99610 100644 --- a/plugin/openssl_plugin/common/src/rsa_openssl_common.c +++ b/plugin/openssl_plugin/common/src/rsa_openssl_common.c @@ -16,95 +16,53 @@ #include "log.h" #include "openssl_common.h" -static HcfResult DuplicateBigNumFromRSA(BIGNUM **n, BIGNUM **e, BIGNUM **d, bool needPrivate, const RSA *rsa) +HcfResult DuplicateRsa(RSA *rsa, bool needPrivate, RSA **dupRsa) { - const BIGNUM *tmpN = NULL, *tmpE = NULL, *tmpD = NULL; - RSA_get0_key(rsa, &tmpN, &tmpE, &tmpD); - if (tmpN == NULL || tmpE == NULL || (needPrivate && tmpD == NULL)) { - LOGE("Rsa get bignum n e d fail."); - return HCF_ERR_CRYPTO_OPERATION; - } - BIGNUM *retN = NULL, *retE = NULL, *retD = NULL; - retN = BN_dup(tmpN); - if (retN == NULL) { - LOGE("Dup n fail"); - goto ERR; - } - retE = BN_dup(tmpE); - if (retE == NULL) { - LOGE("Dup e fail"); - goto ERR; + RSA *retRSA = NULL; + if (rsa == NULL || dupRsa == NULL) { + LOGE("Rsa or dupRsa is NULL."); + return HCF_INVALID_PARAMS; } if (needPrivate) { - retD = BN_dup(tmpD); - if (retD == NULL) { - LOGE("Dup d fail"); - goto ERR; - } - } - *n = retN; - *e = retE; - *d = retD; - - return HCF_SUCCESS; -ERR: - BN_clear_free(retN); - BN_clear_free(retE); - BN_clear_free(retD); - return HCF_ERR_CRYPTO_OPERATION; -} - -static HcfResult InitRsaStruct(BIGNUM *n, BIGNUM *e, BIGNUM *d, const bool needPrivateExponent, RSA **rsa) -{ - HcfResult ret = HCF_ERR_CRYPTO_OPERATION; - if (rsa == NULL || n == NULL || e == NULL) { - LOGE("InitRsaStruct params error."); - ret = HCF_INVALID_PARAMS; - goto ERR; + retRSA = RSAPrivateKey_dup(rsa); + } else { + retRSA = RSAPublicKey_dup(rsa); } - // private key need d, public key can't set key - if ((needPrivateExponent && d == NULL) || (!needPrivateExponent && d != NULL)) { - LOGE("The input BigNum is invalid."); - ret = HCF_INVALID_PARAMS; - goto ERR; - } - *rsa = RSA_new(); - if (*rsa == NULL) { - LOGE("New RSA fail"); - ret = HCF_ERR_MALLOC; - goto ERR; - } - if (RSA_set0_key(*rsa, n, e, d) != HCF_OPENSSL_SUCCESS) { - LOGE("RSA_set0_key fail."); - RSA_free(*rsa); - *rsa = NULL; - ret = HCF_ERR_CRYPTO_OPERATION; - goto ERR; + if (retRSA == NULL) { + LOGE("Duplicate RSA fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; } + *dupRsa = retRSA; return HCF_SUCCESS; -ERR: - BN_clear_free(n); - BN_clear_free(e); - BN_clear_free(d); - return ret; } -HcfResult DuplicateRsa(const RSA *rsa, bool needPrivate, RSA **dupRsa) +EVP_PKEY *NewEvpPkeyByRsa(RSA *rsa, bool withDuplicate) { - if (rsa == NULL || dupRsa == NULL) { - LOGE("Rsa or dupRsa is NULL."); - return HCF_INVALID_PARAMS; + if (rsa == NULL) { + LOGE("RSA is NULL"); + return NULL; } - BIGNUM *n = NULL; - BIGNUM *e = NULL; - BIGNUM *d = NULL; - if (DuplicateBigNumFromRSA(&n, &e, &d, needPrivate, rsa) != HCF_SUCCESS) { - LOGE("duplicate pk bignum fail"); - return HCF_ERR_CRYPTO_OPERATION; + EVP_PKEY *pKey = EVP_PKEY_new(); + if (pKey == NULL) { + LOGE("EVP_PKEY_new fail"); + HcfPrintOpensslError(); + return NULL; } - if (InitRsaStruct(n, e, d, needPrivate, dupRsa) != HCF_SUCCESS) { - LOGE("Generate PriKey fail."); - return HCF_ERR_CRYPTO_OPERATION; + if (withDuplicate) { + if (EVP_PKEY_set1_RSA(pKey, rsa) != HCF_OPENSSL_SUCCESS) { + LOGE("EVP_PKEY_set1_RSA fail"); + HcfPrintOpensslError(); + EVP_PKEY_free(pKey); + return NULL; + } + } else { + if (EVP_PKEY_assign_RSA(pKey, rsa) != HCF_OPENSSL_SUCCESS) { + LOGE("EVP_PKEY_assign_RSA fail"); + HcfPrintOpensslError(); + EVP_PKEY_free(pKey); + return NULL; + } } - return HCF_SUCCESS; -} \ No newline at end of file + return pKey; +} diff --git a/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl.h b/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl.h index 173a09bdc0af6232434bfa36d2a47c6d6c18602d..5fcb3da563c8fd8fd14044ea1f419059145b7c22 100644 --- a/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/aes/inc/aes_openssl.h @@ -15,33 +15,15 @@ #ifndef HCF_AES_OPENSSL_H #define HCF_AES_OPENSSL_H -#include -#include -#include "params_parser.h" #include "cipher_factory_spi.h" -typedef struct { - EVP_CIPHER_CTX *ctx; - enum HcfCryptoMode enc; - /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE need AEAD */ - bool aead; - uint32_t updateLen; - unsigned char *iv; - uint32_t ivLen; - /* GCM, CCM only */ - unsigned char *aad; - uint32_t aadLen; - unsigned char *tag; - uint32_t tagLen; -} CipherData; - #ifdef __cplusplus extern "C" { #endif -HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGeneratorSpi **generator); +HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator); -HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGeneratorSpi **generator); +HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator); #ifdef __cplusplus } diff --git a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_3des_openssl.c b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_3des_openssl.c index c8fed98d3c79077623d163cb25280344e3c0ab3b..5968fadc377507ed1daf72ef038e46ca5340e041 100644 --- a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_3des_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_3des_openssl.c @@ -26,9 +26,10 @@ #include "openssl_class.h" #define DES_BLOCK_SIZE 8 +#define DES_SIZE_192 24 typedef struct { - OH_HCF_CipherGeneratorSpi base; + HcfCipherGeneratorSpi base; CipherAttr attr; CipherData *cipherData; } HcfCipherDesGeneratorSpiOpensslImpl; @@ -38,7 +39,7 @@ static const char *GetDesGeneratorClass(void) return OPENSSL_3DES_CIPHER_CLASS; } -static const EVP_CIPHER *DefautCiherType() +static const EVP_CIPHER *DefaultCipherType(void) { return EVP_des_ede3_ecb(); } @@ -62,7 +63,7 @@ static const EVP_CIPHER *GetCipherType(HcfCipherDesGeneratorSpiOpensslImpl *impl default: break; } - return DefautCiherType(); + return DefaultCipherType(); } static HcfResult InitCipherData(enum HcfCryptoMode opMode, CipherData **cipherData) @@ -90,7 +91,7 @@ clearup: return ret; } -static HcfResult EngineCipherInit(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode opMode, +static HcfResult EngineCipherInit(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) { if ((self == NULL) || (key == NULL)) { /* params maybe is null */ @@ -108,9 +109,12 @@ static HcfResult EngineCipherInit(OH_HCF_CipherGeneratorSpi *self, enum HcfCrypt HcfCipherDesGeneratorSpiOpensslImpl *cipherImpl = (HcfCipherDesGeneratorSpiOpensslImpl *)self; SymKeyImpl *keyImpl = (SymKeyImpl *)key; - int32_t enc = (opMode == ENCRYPT_MODE) ? 1 : 0; + if (keyImpl->keyMaterial.len < DES_SIZE_192) { + LOGE("Init failed, the input key size is smaller than keySize specified in cipher."); + return HCF_INVALID_PARAMS; + } if (InitCipherData(opMode, &(cipherImpl->cipherData)) != HCF_SUCCESS) { LOGE("InitCipherData failed"); return HCF_INVALID_PARAMS; @@ -141,15 +145,10 @@ clearup: static HcfResult AllocateOutput(HcfBlob *input, HcfBlob *output) { - uint32_t outLen = 0; + uint32_t outLen = DES_BLOCK_SIZE; if (IsBlobValid(input)) { outLen += input->len; } - outLen += DES_BLOCK_SIZE; - if (outLen == 0) { - LOGE("output size is invaild!"); - return HCF_INVALID_PARAMS; - } output->data = (uint8_t *)HcfMalloc(outLen, 0); if (output->data == NULL) { LOGE("malloc output failed!"); @@ -159,7 +158,7 @@ static HcfResult AllocateOutput(HcfBlob *input, HcfBlob *output) return HCF_SUCCESS; } -static HcfResult EngineUpdate(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { if ((self == NULL) || (input == NULL) || (output == NULL)) { LOGE("Invalid input parameter!"); @@ -195,6 +194,8 @@ clearup: if (res != HCF_SUCCESS) { HcfBlobDataFree(output); FreeCipherData(&(cipherImpl->cipherData)); + } else { + FreeRedundantOutput(output); } return res; } @@ -224,7 +225,7 @@ static HcfResult DesDoFinal(CipherData *data, HcfBlob *input, HcfBlob *output) return HCF_SUCCESS; } -static HcfResult EngineDoFinal(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { if ((self == NULL) || (output == NULL)) { /* input maybe is null */ LOGE("Invalid input parameter!"); @@ -253,6 +254,8 @@ static HcfResult EngineDoFinal(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, clearup: if (res != HCF_SUCCESS) { HcfBlobDataFree(output); + } else { + FreeRedundantOutput(output); } FreeCipherData(&(cipherImpl->cipherData)); return res; @@ -272,7 +275,7 @@ static void EngineDesGeneratorDestroy(HcfObjectBase *self) HcfFree(impl); } -HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGeneratorSpi **generator) +HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator) { if ((attr == NULL) || (generator == NULL)) { LOGE("Invalid input parameter!"); @@ -291,6 +294,6 @@ HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGenerato returnImpl->base.base.destroy = EngineDesGeneratorDestroy; returnImpl->base.base.getClass = GetDesGeneratorClass; - *generator = (OH_HCF_CipherGeneratorSpi *)returnImpl; + *generator = (HcfCipherGeneratorSpi *)returnImpl; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_common.c b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_common.c index e416e1c75446ca4ecfa4d508c2c428385c56b4bd..933e3073cb4ed216054541a578f17e60013e788d 100644 --- a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_common.c +++ b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_common.c @@ -29,26 +29,6 @@ const unsigned char *GetIv(HcfParamsSpec *params) return (const unsigned char *)iv; } -int32_t GetIvLen(HcfParamsSpec *params) -{ - if (params == NULL) { - return 0; - } - HcfIvParamsSpec *spec = (HcfIvParamsSpec *)params; - size_t ivLen = spec->iv.len; - return (int)ivLen; -} - -int32_t GetGcmTagLen(HcfParamsSpec *params) -{ - if (params == NULL) { - return 0; - } - HcfGcmParamsSpec *spec = (HcfGcmParamsSpec *)params; - size_t tagLen = spec->tag.len; - return (int)tagLen; -} - int32_t GetCcmTagLen(HcfParamsSpec *params) { if (params == NULL) { @@ -59,16 +39,6 @@ int32_t GetCcmTagLen(HcfParamsSpec *params) return (int)tagLen; } -void *GetGcmTag(HcfParamsSpec *params) -{ - if (params == NULL) { - return NULL; - } - HcfGcmParamsSpec *spec = (HcfGcmParamsSpec *)params; - uint8_t *tag = spec->tag.data; - return (void *)tag; -} - void *GetCcmTag(HcfParamsSpec *params) { if (params == NULL) { @@ -103,3 +73,15 @@ void FreeCipherData(CipherData **data) HcfFree(*data); *data = NULL; } + +void FreeRedundantOutput(HcfBlob *blob) +{ + if (blob == NULL) { + return; + } + // when decrypt result is empty plaintext, out blob data maybe not null (malloc by hcf before decryption) + if ((blob->len == 0) && (blob->data != NULL)) { + HcfFree(blob->data); + blob->data = NULL; + } +} \ No newline at end of file diff --git a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_openssl.c index a9b2b8d5d0a33211f774166086fd82617cca0091..ac74eb2fd317a3e1f0961a717979802bba3cf861 100644 --- a/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/aes/src/cipher_aes_openssl.c @@ -31,9 +31,12 @@ #define AES_BLOCK_SIZE 16 #define GCM_TAG_SIZE 16 #define CCM_TAG_SIZE 12 +#define AES_SIZE_128 16 +#define AES_SIZE_192 24 +#define AES_SIZE_256 32 typedef struct { - OH_HCF_CipherGeneratorSpi base; + HcfCipherGeneratorSpi base; CipherAttr attr; CipherData *cipherData; } HcfCipherAesGeneratorSpiOpensslImpl; @@ -43,11 +46,6 @@ static const char *GetAesGeneratorClass(void) return OPENSSL_AES_CIPHER_CLASS; } -static const EVP_CIPHER *DefautCiherType() -{ - return EVP_aes_128_ecb(); -} - static const EVP_CIPHER *CipherEcbType(HCF_ALG_PARA_VALUE value) { switch (value) { @@ -199,6 +197,11 @@ static const EVP_CIPHER *CipherGcmType(HCF_ALG_PARA_VALUE value) return EVP_aes_128_gcm(); } +static const EVP_CIPHER *DefaultCiherType(HCF_ALG_PARA_VALUE value) +{ + return CipherEcbType(value); +} + static const EVP_CIPHER *GetCipherType(HcfCipherAesGeneratorSpiOpensslImpl *impl) { switch (impl->attr.mode) { @@ -225,7 +228,7 @@ static const EVP_CIPHER *GetCipherType(HcfCipherAesGeneratorSpiOpensslImpl *impl default: break; } - return DefautCiherType(); + return DefaultCiherType(impl->attr.keySize); } static bool IsGcmParamsValid(HcfGcmParamsSpec *params) @@ -330,7 +333,7 @@ static HcfResult InitAadAndTagFromCcmParams(enum HcfCryptoMode opMode, HcfCcmPar return HCF_SUCCESS; } -static HcfResult InitCipherData(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode opMode, +static HcfResult InitCipherData(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfParamsSpec *params, CipherData **cipherData) { HcfResult ret = HCF_ERR_MALLOC; @@ -346,7 +349,7 @@ static HcfResult InitCipherData(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoM (*cipherData)->ctx = EVP_CIPHER_CTX_new(); if ((*cipherData)->ctx == NULL) { HcfPrintOpensslError(); - LOGE("Failed to allocate ctx memroy!"); + LOGE("Failed to allocate ctx memory!"); goto clearup; } @@ -366,29 +369,46 @@ clearup: return ret; } -static HcfResult EngineCipherInit(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode opMode, +static HcfResult IsKeySizeMatchCipher(SymKeyImpl *keyImpl, HcfCipherAesGeneratorSpiOpensslImpl *cipherImpl) +{ + size_t keySize = keyImpl->keyMaterial.len; + HCF_ALG_PARA_VALUE cipherValue = cipherImpl->attr.keySize; + switch (cipherValue) { + case HCF_ALG_AES_128: + return (keySize < AES_SIZE_128) ? HCF_INVALID_PARAMS : HCF_SUCCESS; + case HCF_ALG_AES_192: + return (keySize < AES_SIZE_192) ? HCF_INVALID_PARAMS : HCF_SUCCESS; + case HCF_ALG_AES_256: + return (keySize < AES_SIZE_256) ? HCF_INVALID_PARAMS : HCF_SUCCESS; + default: + return HCF_INVALID_PARAMS; + } +} + +static HcfResult EngineCipherInit(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) { - if ((self == NULL) || (key == NULL)) { /* params maybe is null */ + // params spec may be null, do not check + if ((self == NULL) || (key == NULL)) { LOGE("Invalid input parameter!"); return HCF_INVALID_PARAMS; } - if (!IsClassMatch((const HcfObjectBase *)self, GetAesGeneratorClass())) { - LOGE("Class is not match."); - return HCF_INVALID_PARAMS; - } - if (!IsClassMatch((const HcfObjectBase *)key, OPENSSL_SYM_KEY_CLASS)) { - LOGE("Class is not match."); + if ((!IsClassMatch((const HcfObjectBase *)self, GetAesGeneratorClass())) || + (!IsClassMatch((const HcfObjectBase *)key, OPENSSL_SYM_KEY_CLASS))) { return HCF_INVALID_PARAMS; } HcfCipherAesGeneratorSpiOpensslImpl *cipherImpl = (HcfCipherAesGeneratorSpiOpensslImpl *)self; SymKeyImpl *keyImpl = (SymKeyImpl *)key; int enc = (opMode == ENCRYPT_MODE) ? 1 : 0; - + if (IsKeySizeMatchCipher(keyImpl, cipherImpl) != HCF_SUCCESS) { + LOGE("Init failed, key size is smaller than cipher size."); + return HCF_INVALID_PARAMS; + } if (InitCipherData(self, opMode, params, &(cipherImpl->cipherData)) != HCF_SUCCESS) { LOGE("InitCipherData failed!"); return HCF_INVALID_PARAMS; } + CipherData *data = cipherImpl->cipherData; HcfResult ret = HCF_ERR_CRYPTO_OPERATION; if (EVP_CipherInit(data->ctx, GetCipherType(cipherImpl), keyImpl->keyMaterial.data, GetIv(params), enc) != @@ -460,16 +480,11 @@ static HcfResult AeadUpdate(CipherData *data, HCF_ALG_PARA_VALUE mode, HcfBlob * static HcfResult AllocateOutput(HcfBlob *input, HcfBlob *output, bool *isUpdateInput) { - uint32_t outLen = 0; + uint32_t outLen = AES_BLOCK_SIZE; if (IsBlobValid(input)) { outLen += input->len; *isUpdateInput = true; } - outLen += AES_BLOCK_SIZE; - if (outLen == 0) { - LOGE("output size is invaild!"); - return HCF_INVALID_PARAMS; - } output->data = (uint8_t *)HcfMalloc(outLen, 0); if (output->data == NULL) { LOGE("malloc output failed!"); @@ -479,7 +494,7 @@ static HcfResult AllocateOutput(HcfBlob *input, HcfBlob *output, bool *isUpdateI return HCF_SUCCESS; } -static HcfResult EngineUpdate(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { if ((self == NULL) || (input == NULL) || (output == NULL)) { LOGE("Invalid input parameter!"); @@ -513,6 +528,7 @@ static HcfResult EngineUpdate(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, H FreeCipherData(&(cipherImpl->cipherData)); } data->aead = false; + FreeRedundantOutput(output); return ret; } @@ -706,7 +722,7 @@ static HcfResult GcmDoFinal(CipherData *data, HcfBlob *input, HcfBlob *output) } } -static HcfResult EngineDoFinal(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { if ((self == NULL) || (output == NULL)) { /* input maybe is null */ LOGE("Invalid input parameter!"); @@ -737,6 +753,7 @@ static HcfResult EngineDoFinal(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, if (ret != HCF_SUCCESS) { HcfBlobDataFree(output); } + FreeRedundantOutput(output); return ret; } @@ -755,7 +772,7 @@ static void EngineAesGeneratorDestroy(HcfObjectBase *self) HcfFree(impl); } -HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGeneratorSpi **generator) +HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator) { if ((attr == NULL) || (generator == NULL)) { LOGE("Invalid input parameter."); @@ -774,6 +791,6 @@ HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, OH_HCF_CipherGenerato returnImpl->base.base.destroy = EngineAesGeneratorDestroy; returnImpl->base.base.getClass = GetAesGeneratorClass; - *generator = (OH_HCF_CipherGeneratorSpi *)returnImpl; + *generator = (HcfCipherGeneratorSpi *)returnImpl; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h b/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h index c70c390983fb6b78e2e6eabc9369dd90c2f46338..419dc306ea4a9ef80ec03ffb33e15884638117bb 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h @@ -17,6 +17,8 @@ #include "mac_spi.h" +#define HCF_OPENSSL_INVALID_MAC_LEN 0 + #ifdef __cplusplus extern "C" { #endif diff --git a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c index 00abbbf4ea604f3b5df212a9439baf211757d736..958ffa911aced914d92bb623ac68f7a45c5c883f 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c @@ -125,12 +125,7 @@ static HcfResult OpensslEngineDoFinalMac(HcfMacSpi *self, HcfBlob *output) LOGE("Failed to allocate output->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(output->data, outputLen, outputBuf, outputLen) != EOK) { - LOGE("memcpy error!"); - HcfFree(output->data); - output->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); output->len = outputLen; return HCF_SUCCESS; } @@ -139,7 +134,7 @@ static uint32_t OpensslEngineGetMacLength(HcfMacSpi *self) { if (OpensslGetMacCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return HCF_ERR_CRYPTO_OPERATION; + return HCF_OPENSSL_INVALID_MAC_LEN; } return HMAC_size(OpensslGetMacCtx(self)); } diff --git a/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c b/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c index de061eda61997e0824c109f0730b6b07be45f698..2ab284af9c793cc1bbe1279e8fff92732ac4bb6c 100644 --- a/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c @@ -19,6 +19,7 @@ #include #include "algorithm_parameter.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "log.h" @@ -33,26 +34,26 @@ typedef struct { static EVP_PKEY *NewPKeyByEccPubKey(int32_t curveId, HcfOpensslEccPubKey *publicKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return NULL; } - if (EC_KEY_set_public_key(ecKey, (publicKey->pk)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_public_key(ecKey, (publicKey->pk)) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return NULL; } return pKey; @@ -60,26 +61,26 @@ static EVP_PKEY *NewPKeyByEccPubKey(int32_t curveId, HcfOpensslEccPubKey *public static EVP_PKEY *NewPKeyByEccPriKey(int32_t curveId, HcfOpensslEccPriKey *privateKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return NULL; } - if (EC_KEY_set_private_key(ecKey, (privateKey->sk)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_private_key(ecKey, (privateKey->sk)) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); EC_KEY_free(ecKey); return NULL; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return NULL; } return pKey; @@ -87,41 +88,41 @@ static EVP_PKEY *NewPKeyByEccPriKey(int32_t curveId, HcfOpensslEccPriKey *privat static HcfResult EcdhDerive(EVP_PKEY *priPKey, EVP_PKEY *pubPKey, HcfBlob *returnSecret) { - EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(priPKey, NULL); + EVP_PKEY_CTX *ctx = Openssl_EVP_PKEY_CTX_new(priPKey, NULL); if (ctx == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_derive_init(ctx) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive_init(ctx) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_derive_set_peer(ctx, pubPKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive_set_peer(ctx, pubPKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } size_t maxLen; - if (EVP_PKEY_derive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } uint8_t *secretData = (uint8_t *)HcfMalloc(maxLen, 0); if (secretData == NULL) { LOGE("Failed to allocate secretData memory!"); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_MALLOC; } size_t actualLen = maxLen; - if (EVP_PKEY_derive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); HcfFree(secretData); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); if (actualLen > maxLen) { LOGE("signature data too long."); HcfFree(secretData); @@ -176,8 +177,8 @@ static HcfResult EngineGenerateSecret(HcfKeyAgreementSpi *self, HcfPriKey *priKe } int32_t res = EcdhDerive(priPKey, pubPKey, returnSecret); - EVP_PKEY_free(priPKey); - EVP_PKEY_free(pubPKey); + Openssl_EVP_PKEY_free(priPKey); + Openssl_EVP_PKEY_free(pubPKey); LOGI("end ..."); return res; } diff --git a/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h b/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h index 4a624320080a53a801d8cb872994d2b8e5ab6f11..fb4716e2bfbd7df0a928329988b687d0a0a6cac0 100644 --- a/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h @@ -17,6 +17,8 @@ #include "md_spi.h" +#define HCF_OPENSSL_INVALID_MD_LEN 0 + #ifdef __cplusplus extern "C" { #endif diff --git a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c index fc8bae5cfbdcec45ffaa5fa6afae859f7cbe783c..a7aa1973c88a3a52b21ee42f17ef5d395dbacad0 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -98,12 +98,7 @@ static HcfResult OpensslEngineDoFinalMd(HcfMdSpi *self, HcfBlob *output) LOGE("Failed to allocate output->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(output->data, outputLen, outputBuf, outputLen) != EOK) { - LOGE("memcpy error!"); - HcfFree(output->data); - output->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); output->len = outputLen; return HCF_SUCCESS; } @@ -112,12 +107,12 @@ static uint32_t OpensslEngineGetMdLength(HcfMdSpi *self) { if (OpensslGetMdCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return 0; + return HCF_OPENSSL_INVALID_MD_LEN; } int32_t size = EVP_MD_CTX_size(OpensslGetMdCtx(self)); if (size < 0) { LOGE("Get the overflow path length in openssl!"); - return 0; + return HCF_OPENSSL_INVALID_MD_LEN; } return size; } diff --git a/plugin/openssl_plugin/crypto_operation/rsa/inc/cipher_rsa_openssl.h b/plugin/openssl_plugin/crypto_operation/rsa/inc/cipher_rsa_openssl.h index 5684edc52675b579d875f18d563c9d6f26cddce1..27b60cd9983f3b2518a32f386bbc3883d4426ae5 100644 --- a/plugin/openssl_plugin/crypto_operation/rsa/inc/cipher_rsa_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/rsa/inc/cipher_rsa_openssl.h @@ -22,7 +22,7 @@ extern "C" { #endif -HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, OH_HCF_CipherGeneratorSpi **generator); +HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, HcfCipherGeneratorSpi **generator); #ifdef __cplusplus } diff --git a/plugin/openssl_plugin/crypto_operation/rsa/src/cipher_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/rsa/src/cipher_rsa_openssl.c index b6b48d060a5069999d3a6a11329100286c0b9410..63261646d5b66cf04976c1b687472aaeaecdecba 100644 --- a/plugin/openssl_plugin/crypto_operation/rsa/src/cipher_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/rsa/src/cipher_rsa_openssl.c @@ -28,7 +28,7 @@ static const char *EngineGetClass(void); typedef struct { - OH_HCF_CipherGeneratorSpi super; + HcfCipherGeneratorSpi super; CipherAttr attr; @@ -91,17 +91,11 @@ static HcfResult InitEvpPkeyCtx(HcfCipherRsaGeneratorSpiImpl *impl, HcfKey *key, LOGE("DuplicateRsaFromKey fail."); return ret; } - EVP_PKEY *pkey = EVP_PKEY_new(); + EVP_PKEY *pkey = NewEvpPkeyByRsa(rsa, false); if (pkey == NULL) { - LOGE("New EVP_PKEY fail."); + LOGE("NewEvpPkeyByRsa fail"); HcfPrintOpensslError(); - return HCF_ERR_CRYPTO_OPERATION; - } - - if (EVP_PKEY_assign_RSA(pkey, rsa) != HCF_OPENSSL_SUCCESS) { - LOGE("EVP_PKEY_assign_RSA fail"); - HcfPrintOpensslError(); - EVP_PKEY_free(pkey); + RSA_free(rsa); return HCF_ERR_CRYPTO_OPERATION; } impl->ctx = EVP_PKEY_CTX_new(pkey, NULL); @@ -163,19 +157,14 @@ static HcfResult SetDetailParams(HcfCipherRsaGeneratorSpiImpl *impl) return HCF_SUCCESS; } -static HcfResult EngineInit(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode opMode, +static HcfResult EngineInit(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) { LOGI("EngineInit start"); - if (self == NULL || key == NULL) { - LOGE("Param is invalid."); - return HCF_INVALID_PARAMS; - } if (!IsClassMatch((HcfObjectBase *)self, EngineGetClass())) { LOGE("Class not match"); return HCF_INVALID_PARAMS; } - HcfCipherRsaGeneratorSpiImpl *impl = (HcfCipherRsaGeneratorSpiImpl *)self; if (impl->initFlag != UNINITIALIZED) { LOGE("The cipher has been initialize, don't init again."); @@ -203,7 +192,7 @@ static HcfResult EngineInit(OH_HCF_CipherGeneratorSpi *self, enum HcfCryptoMode return HCF_SUCCESS; } -static HcfResult EngineUpdata(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineUpdata(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { LOGE("Openssl don't support update"); (void)self; @@ -230,7 +219,7 @@ static HcfResult DoRsaCrypt(EVP_PKEY_CTX *ctx, HcfBlob *input, HcfBlob *output, return HCF_SUCCESS; } -static HcfResult EngineDoFinal(OH_HCF_CipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) +static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBlob *output) { LOGI("EngineDoFinal start"); if (self == NULL || input == NULL || input->data == NULL) { @@ -316,7 +305,7 @@ static HcfResult CheckRsaCipherParams(CipherAttr *params) return HCF_SUCCESS; } -HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, OH_HCF_CipherGeneratorSpi **generator) +HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, HcfCipherGeneratorSpi **generator) { LOGI("Start create rsa cipher spiObj."); if (generator == NULL || params == NULL) { @@ -329,11 +318,7 @@ HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, OH_HCF_CipherGenerator LOGE("Malloc rsa cipher fail."); return HCF_ERR_MALLOC; } - if (memcpy_s(&returnImpl->attr, sizeof(CipherAttr), params, sizeof(CipherAttr)) != HCF_SUCCESS) { - LOGE("memcpuy_s CipherAttr fail."); - HcfFree(returnImpl); - return HCF_ERR_COPY; - } + (void)memcpy_s(&returnImpl->attr, sizeof(CipherAttr), params, sizeof(CipherAttr)); if (CheckRsaCipherParams(&returnImpl->attr) != HCF_SUCCESS) { HcfFree(returnImpl); @@ -347,7 +332,7 @@ HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, OH_HCF_CipherGenerator returnImpl->super.base.destroy = EngineDestroySpiImpl; returnImpl->super.base.getClass = EngineGetClass; returnImpl->initFlag = UNINITIALIZED; - *generator = (OH_HCF_CipherGeneratorSpi *)returnImpl; + *generator = (HcfCipherGeneratorSpi *)returnImpl; LOGI("Rsa Cipher create success."); return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c index 89c0e46c56e91261325eba6eeed1cdd217a1e12c..8701015a7c556fafb7f2a7d5fc55b9b196a23831 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c @@ -19,6 +19,7 @@ #include #include "algorithm_parameter.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "log.h" @@ -89,7 +90,7 @@ static void DestroyEcdsaSign(HcfObjectBase *self) return; } HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; - EVP_MD_CTX_destroy(impl->ctx); + Openssl_EVP_MD_CTX_free(impl->ctx); impl->ctx = NULL; HcfFree(impl); } @@ -103,7 +104,7 @@ static void DestroyEcdsaVerify(HcfObjectBase *self) return; } HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; - EVP_MD_CTX_destroy(impl->ctx); + Openssl_EVP_MD_CTX_free(impl->ctx); impl->ctx = NULL; HcfFree(impl); } @@ -126,34 +127,34 @@ static HcfResult EngineSignInit(HcfSignSpi *self, HcfParamsSpec *params, HcfPriK LOGE("Repeated initialization is not allowed."); return HCF_INVALID_PARAMS; } - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_private_key(ecKey, ((HcfOpensslEccPriKey *)privateKey)->sk) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_private_key(ecKey, ((HcfOpensslEccPriKey *)privateKey)->sk) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_DigestSignInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); impl->status = INITIALIZED; LOGI("end ..."); return HCF_SUCCESS; @@ -174,7 +175,7 @@ static HcfResult EngineSignUpdate(HcfSignSpi *self, HcfBlob *data) LOGE("Sign object has not been initialized."); return HCF_INVALID_PARAMS; } - if (EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -196,7 +197,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; if (IsBlobValid(data)) { - if (EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -207,7 +208,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_INVALID_PARAMS; } size_t maxLen; - if (EVP_DigestSignFinal(impl->ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -217,7 +218,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_ERR_MALLOC; } size_t actualLen = maxLen; - if (EVP_DigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; @@ -252,34 +253,34 @@ static HcfResult EngineVerifyInit(HcfVerifySpi *self, HcfParamsSpec *params, Hcf LOGE("Repeated initialization is not allowed."); return HCF_INVALID_PARAMS; } - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_public_key(ecKey, ((HcfOpensslEccPubKey *)publicKey)->pk) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_public_key(ecKey, ((HcfOpensslEccPubKey *)publicKey)->pk) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_DigestVerifyInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); impl->status = INITIALIZED; LOGI("end ..."); return HCF_SUCCESS; @@ -301,7 +302,7 @@ static HcfResult EngineVerifyUpdate(HcfVerifySpi *self, HcfBlob *data) LOGE("Verify object has not been initialized."); return HCF_INVALID_PARAMS; } - if (EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -323,7 +324,7 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign HcfVerifySpiEcdsaOpensslImpl *impl = (HcfVerifySpiEcdsaOpensslImpl *)self; if (IsBlobValid(data)) { - if (EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } @@ -333,7 +334,7 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign LOGE("The message has not been transferred."); return false; } - if (EVP_DigestVerifyFinal(impl->ctx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyFinal(impl->ctx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } @@ -355,9 +356,6 @@ HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnO return HCF_INVALID_PARAMS; } const EVP_MD *opensslAlg = GetOpensslDigestAlg(params->md); - if (opensslAlg == NULL) { - return HCF_INVALID_PARAMS; - } HcfSignSpiEcdsaOpensslImpl *returnImpl = (HcfSignSpiEcdsaOpensslImpl *)HcfMalloc( sizeof(HcfSignSpiEcdsaOpensslImpl), 0); @@ -373,7 +371,7 @@ HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnO returnImpl->curveId = curveId; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = EVP_MD_CTX_create(); + returnImpl->ctx = Openssl_EVP_MD_CTX_new(); if (returnImpl->ctx == NULL) { LOGE("Failed to allocate ctx memory!"); HcfFree(returnImpl); @@ -398,9 +396,6 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret return HCF_INVALID_PARAMS; } const EVP_MD *opensslAlg = GetOpensslDigestAlg(params->md); - if (opensslAlg == NULL) { - return HCF_INVALID_PARAMS; - } HcfVerifySpiEcdsaOpensslImpl *returnImpl = (HcfVerifySpiEcdsaOpensslImpl *)HcfMalloc( sizeof(HcfVerifySpiEcdsaOpensslImpl), 0); @@ -416,7 +411,7 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret returnImpl->curveId = curveId; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = EVP_MD_CTX_create(); + returnImpl->ctx = Openssl_EVP_MD_CTX_new(); if (returnImpl->ctx == NULL) { LOGE("Failed to allocate ctx memory!"); HcfFree(returnImpl); diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c index 9c282b3ee7cef359762110f132c02a9a34eb61e8..a07148a475ea521286522760559ce0d5b90d513d 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c @@ -124,23 +124,16 @@ static EVP_PKEY *InitRsaEvpKey(const HcfKey *key, bool signing) return NULL; } if (rsa == NULL) { - LOGE("The Key is has lost."); + LOGE("The Key has lost."); return NULL; } - EVP_PKEY *pkey = EVP_PKEY_new(); + EVP_PKEY *pkey = NewEvpPkeyByRsa(rsa, false); if (pkey == NULL) { LOGE("New evp pkey failed"); HcfPrintOpensslError(); RSA_free(rsa); return NULL; } - if (EVP_PKEY_assign_RSA(pkey, rsa) != HCF_OPENSSL_SUCCESS) { - LOGE("EVP_PKEY_assign_RSA fail."); - HcfPrintOpensslError(); - RSA_free(rsa); - EVP_PKEY_free(pkey); - return NULL; - } return pkey; } @@ -385,7 +378,7 @@ static bool EngineVerify(HcfVerifySpi *self, HcfBlob *data, HcfBlob *signatureDa HcfVerifySpiRsaOpensslImpl *impl = (HcfVerifySpiRsaOpensslImpl *)self; if (impl->initFlag != INITIALIZED) { LOGE("The Sign has not been init"); - return HCF_INVALID_PARAMS; + return false; } if (data != NULL && data->data != NULL) { if (EVP_DigestVerifyUpdate(impl->mdctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_asy_key_generator_openssl.c index 6e9a56dafdc1653efe5fc355ac85a35fda4625a8..981d7e1c659356a965bf2c08be0d275956de12b2 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_asy_key_generator_openssl.c @@ -15,12 +15,12 @@ #include "ecc_asy_key_generator_openssl.h" -#include -#include +#include "securec.h" #include "algorithm_parameter.h" #include "log.h" #include "memory.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "utils.h" @@ -38,46 +38,46 @@ typedef struct { static HcfResult NewEcKeyPairByOpenssl(int32_t curveId, EC_POINT **returnPubKey, BIGNUM **returnPriKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { LOGE("new ec key failed."); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_generate_key(ecKey) <= 0) { + if (Openssl_EC_KEY_generate_key(ecKey) <= 0) { LOGE("generate ec key failed."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_check_key(ecKey) <= 0) { + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { LOGE("check key fail."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - const EC_POINT *pubKey = EC_KEY_get0_public_key(ecKey); - const BIGNUM *priKey = EC_KEY_get0_private_key(ecKey); - const EC_GROUP *group = EC_KEY_get0_group(ecKey); + const EC_POINT *pubKey = Openssl_EC_KEY_get0_public_key(ecKey); + const BIGNUM *priKey = Openssl_EC_KEY_get0_private_key(ecKey); + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); if ((pubKey == NULL) || (priKey == NULL) || (group == NULL)) { LOGE("ec key is invalid."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EC_POINT *newPubKey = EC_POINT_dup(pubKey, group); + EC_POINT *newPubKey = Openssl_EC_POINT_dup(pubKey, group); if (newPubKey == NULL) { LOGE("copy pubKey fail."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - BIGNUM *newPriKey = BN_dup(priKey); + BIGNUM *newPriKey = Openssl_BN_dup(priKey); if (newPriKey == NULL) { - LOGE("copy pubKey fail."); - EC_KEY_free(ecKey); - EC_POINT_free(newPubKey); + LOGE("copy priKey fail."); + Openssl_EC_KEY_free(ecKey); + Openssl_EC_POINT_free(newPubKey); return HCF_ERR_CRYPTO_OPERATION; } *returnPubKey = newPubKey; *returnPriKey = newPriKey; - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_SUCCESS; } @@ -113,26 +113,6 @@ static void DestroyEccKeyPairGenerator(HcfObjectBase *self) HcfFree(self); } -static void DestroyEccKeyPair(HcfObjectBase *self) -{ - if (self == NULL) { - return; - } - if (!IsClassMatch(self, GetEccKeyPairClass())) { - return; - } - HcfOpensslEccKeyPair *impl = (HcfOpensslEccKeyPair *)self; - if (impl->base.pubKey != NULL) { - OH_HCF_OBJ_DESTROY(impl->base.pubKey); - impl->base.pubKey = NULL; - } - if (impl->base.priKey != NULL) { - OH_HCF_OBJ_DESTROY(impl->base.priKey); - impl->base.priKey = NULL; - } - HcfFree(impl); -} - static void DestroyEccPubKey(HcfObjectBase *self) { if (self == NULL) { @@ -161,6 +141,31 @@ static void DestroyEccPriKey(HcfObjectBase *self) HcfFree(impl); } +static void DestroyEccKeyPair(HcfObjectBase *self) +{ + if (self == NULL) { + return; + } + if (!IsClassMatch(self, GetEccKeyPairClass())) { + return; + } + HcfOpensslEccKeyPair *impl = (HcfOpensslEccKeyPair *)self; + if (impl->base.pubKey != NULL) { + DestroyEccPubKey((HcfObjectBase *)impl->base.pubKey); + impl->base.pubKey = NULL; + } + if (impl->base.priKey != NULL) { + DestroyEccPriKey((HcfObjectBase *)impl->base.priKey); + impl->base.priKey = NULL; + } + HcfFree(impl); +} + +static void DestroyKey(HcfObjectBase *self) +{ + LOGI("Process DestroyKey"); +} + static const char *GetEccPubKeyAlgorithm(HcfKey *self) { if (self == NULL) { @@ -221,32 +226,28 @@ static HcfResult GetEccPubKeyEncoded(HcfKey *self, HcfBlob *returnBlob) } HcfOpensslEccPubKey *impl = (HcfOpensslEccPubKey *)self; - if (impl->pk == NULL) { - LOGE("Empty public key!"); - return HCF_INVALID_PARAMS; - } - EC_GROUP *group = EC_GROUP_new_by_curve_name(impl->curveId); - if (group == NULL) { + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); + if (ecKey == NULL) { + LOGE("EC_KEY_new_by_curve_name fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - uint32_t maxLen = EC_POINT_point2oct(group, impl->pk, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, NULL); - uint8_t *outData = (uint8_t *)HcfMalloc(maxLen, 0); - if (outData == NULL) { - LOGE("Failed to allocate outData memory!"); - EC_GROUP_free(group); - return HCF_ERR_MALLOC; + if (Openssl_EC_KEY_set_public_key(ecKey, impl->pk) <= 0) { + LOGE("EC_KEY_set_public_key fail."); + HcfPrintOpensslError(); + EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; } - uint32_t actualLen = EC_POINT_point2oct(group, impl->pk, POINT_CONVERSION_UNCOMPRESSED, outData, maxLen, NULL); - EC_GROUP_free(group); - if (actualLen <= 0) { + unsigned char *returnData = NULL; + int returnDataLen = Openssl_i2d_EC_PUBKEY(ecKey, &returnData); + Openssl_EC_KEY_free(ecKey); + if (returnDataLen <= 0) { + LOGE("i2d_EC_PUBKEY fail"); HcfPrintOpensslError(); - HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; } - - returnBlob->data = outData; - returnBlob->len = actualLen; + returnBlob->data = returnData; + returnBlob->len = returnDataLen; LOGI("end ..."); return HCF_SUCCESS; } @@ -263,25 +264,30 @@ static HcfResult GetEccPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob) } HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self; - if (impl->sk == NULL) { - LOGE("Empty private key!"); - return HCF_INVALID_PARAMS; + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); + if (ecKey == NULL) { + LOGE("EC_KEY_new_by_curve_name fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; } - uint32_t maxLen = BN_num_bytes(impl->sk); - uint8_t *outData = (uint8_t *)HcfMalloc(maxLen, 0); - if (outData == NULL) { - LOGE("Failed to allocate outData memory!"); - return HCF_ERR_MALLOC; + if (Openssl_EC_KEY_set_private_key(ecKey, (impl->sk)) != HCF_OPENSSL_SUCCESS) { + LOGE("EC_KEY_set_private_key fail."); + HcfPrintOpensslError(); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; } - uint32_t actualLen = BN_bn2binpad(impl->sk, outData, maxLen); - if (actualLen <= 0) { + Openssl_EC_KEY_set_asn1_flag(ecKey, OPENSSL_EC_NAMED_CURVE); + Openssl_EC_KEY_set_enc_flags(ecKey, EC_PKEY_NO_PUBKEY); + unsigned char *returnData = NULL; + int returnDataLen = Openssl_i2d_ECPrivateKey(ecKey, &returnData); + Openssl_EC_KEY_free(ecKey); + if (returnDataLen <= 0) { + LOGE("i2d_ECPrivateKey fail."); HcfPrintOpensslError(); - HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; } - - returnBlob->data = outData; - returnBlob->len = actualLen; + returnBlob->data = returnData; + returnBlob->len = returnDataLen; LOGI("end ..."); return HCF_SUCCESS; } @@ -295,7 +301,7 @@ static void EccPriKeyClearMem(HcfPriKey *self) return; } HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self; - BN_clear(impl->sk); + Openssl_BN_clear(impl->sk); } static HcfResult CreateEccPubKey(int32_t curveId, EC_POINT *pubKey, HcfOpensslEccPubKey **returnObj) @@ -305,7 +311,7 @@ static HcfResult CreateEccPubKey(int32_t curveId, EC_POINT *pubKey, HcfOpensslEc LOGE("Failed to allocate returnPubKey memory!"); return HCF_ERR_MALLOC; } - returnPubKey->base.base.base.destroy = DestroyEccPubKey; + returnPubKey->base.base.base.destroy = DestroyKey; returnPubKey->base.base.base.getClass = GetEccPubKeyClass; returnPubKey->base.base.getAlgorithm = GetEccPubKeyAlgorithm; returnPubKey->base.base.getEncoded = GetEccPubKeyEncoded; @@ -324,7 +330,7 @@ static HcfResult CreateEccPriKey(int32_t curveId, BIGNUM *priKey, HcfOpensslEccP LOGE("Failed to allocate returnPriKey memory!"); return HCF_ERR_MALLOC; } - returnPriKey->base.base.base.destroy = DestroyEccPriKey; + returnPriKey->base.base.base.destroy = DestroyKey; returnPriKey->base.base.base.getClass = GetEccPriKeyClass; returnPriKey->base.base.getAlgorithm = GetEccPriKeyAlgorithm; returnPriKey->base.base.getEncoded = GetEccPriKeyEncoded; @@ -356,27 +362,30 @@ static HcfResult CreateEccKeyPair(HcfOpensslEccPubKey *pubKey, HcfOpensslEccPriK static HcfResult ConvertEcPubKeyByOpenssl(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpensslEccPubKey **returnPubKey) { - EC_GROUP *group = EC_GROUP_new_by_curve_name(curveId); - if (group == NULL) { + const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data); + EC_KEY *ecKey = Openssl_d2i_EC_PUBKEY(NULL, &tmpData, pubKeyBlob->len); + if (ecKey == NULL) { + LOGE("d2i_EC_PUBKEY fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - EC_POINT *point = EC_POINT_new(group); - if (point == NULL) { + const EC_POINT *pubKey = Openssl_EC_KEY_get0_public_key(ecKey); + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); + if (pubKey == NULL || group == NULL) { + LOGE("ec key is invalid."); HcfPrintOpensslError(); - EC_GROUP_free(group); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_POINT_oct2point(group, point, pubKeyBlob->data, pubKeyBlob->len, NULL) != HCF_OPENSSL_SUCCESS) { - HcfPrintOpensslError(); - EC_POINT_free(point); - EC_GROUP_free(group); + EC_POINT *newPubKey = Openssl_EC_POINT_dup(pubKey, group); + Openssl_EC_KEY_free(ecKey); + if (newPubKey == NULL) { + LOGE("copy pubKey fail."); return HCF_ERR_CRYPTO_OPERATION; } - EC_GROUP_free(group); - int32_t res = CreateEccPubKey(curveId, point, returnPubKey); + int32_t res = CreateEccPubKey(curveId, newPubKey, returnPubKey); if (res != HCF_SUCCESS) { - EC_POINT_free(point); + Openssl_EC_POINT_free(newPubKey); return res; } return HCF_SUCCESS; @@ -384,14 +393,29 @@ static HcfResult ConvertEcPubKeyByOpenssl(int32_t curveId, HcfBlob *pubKeyBlob, static HcfResult ConvertEcPriKeyByOpenssl(int32_t curveId, HcfBlob *priKeyBlob, HcfOpensslEccPriKey **returnPriKey) { - BIGNUM *bn = BN_bin2bn(priKeyBlob->data, priKeyBlob->len, NULL); - if (bn == NULL) { + const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data); + EC_KEY *ecKey = Openssl_d2i_ECPrivateKey(NULL, &tmpData, priKeyBlob->len); + if (ecKey == NULL) { + LOGE("d2i_ECPrivateKey fail"); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - int32_t res = CreateEccPriKey(curveId, bn, returnPriKey); + const BIGNUM *priKey = Openssl_EC_KEY_get0_private_key(ecKey); + if (priKey == NULL) { + LOGE("ec key is invalid."); + HcfPrintOpensslError(); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + BIGNUM *newPriKey = Openssl_BN_dup(priKey); + Openssl_EC_KEY_free(ecKey); + if (newPriKey == NULL) { + LOGE("copy priKey fail."); + return HCF_ERR_CRYPTO_OPERATION; + } + int32_t res = CreateEccPriKey(curveId, newPriKey, returnPriKey); if (res != HCF_SUCCESS) { - BN_clear_free(bn); + Openssl_BN_clear_free(newPriKey); return res; } return HCF_SUCCESS; @@ -437,8 +461,8 @@ static HcfResult EngineConvertEccKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec res = CreateEccKeyPair(pubKey, priKey, &keyPair); } while (0); if (res != HCF_SUCCESS) { - OH_HCF_OBJ_DESTROY(pubKey); - OH_HCF_OBJ_DESTROY(priKey); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); return res; } @@ -468,22 +492,22 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * HcfOpensslEccPubKey *pubKey = NULL; res = CreateEccPubKey(impl->curveId, ecPubKey, &pubKey); if (res != HCF_SUCCESS) { - EC_POINT_free(ecPubKey); - BN_clear_free(ecPriKey); + Openssl_EC_POINT_free(ecPubKey); + Openssl_BN_clear_free(ecPriKey); return res; } HcfOpensslEccPriKey *priKey = NULL; res = CreateEccPriKey(impl->curveId, ecPriKey, &priKey); if (res != HCF_SUCCESS) { - OH_HCF_OBJ_DESTROY(pubKey); - BN_clear_free(ecPriKey); + HcfObjDestroy(pubKey); + Openssl_BN_clear_free(ecPriKey); return res; } HcfOpensslEccKeyPair *returnKeyPair = (HcfOpensslEccKeyPair *)HcfMalloc(sizeof(HcfOpensslEccKeyPair), 0); if (returnKeyPair == NULL) { LOGE("Failed to allocate returnKeyPair memory!"); - OH_HCF_OBJ_DESTROY(pubKey); - OH_HCF_OBJ_DESTROY(priKey); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); return HCF_ERR_MALLOC; } returnKeyPair->base.base.getClass = GetEccKeyPairClass; diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c index 893207cd501dd83fd67b5d3919faee74f66222c9..66c08ae64c39fbc4d12455892c01a6a0dcfe712a 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c @@ -14,10 +14,11 @@ */ #include "rsa_asy_key_generator_openssl.h" +#include "openssl/pem.h" +#include "openssl/x509.h" #include "algorithm_parameter.h" #include "asy_key_generator_spi.h" #include "log.h" - #include "memory.h" #include "openssl_class.h" #include "openssl_common.h" @@ -49,16 +50,6 @@ enum OpensslRsaPrimesSize { OPENSSL_RSA_PRIMES_SIZE_5 = 5, }; -typedef struct { - uint32_t keySize; - - uint32_t nSize; - - uint32_t eSize; - - uint32_t dSize; -} KeyMaterialRsa; - typedef struct { int32_t bits; int32_t primes; @@ -73,10 +64,6 @@ typedef struct { static HcfResult CheckRsaKeyGenParams(HcfAsyKeyGenSpiRsaParams *params) { - if (params->pubExp == NULL) { - LOGE("pubExp is NULL."); - return HCF_INVALID_PARAMS; - } switch (params->bits) { case OPENSSL_RSA_KEY_SIZE_512: case OPENSSL_RSA_KEY_SIZE_768: @@ -99,11 +86,7 @@ static HcfResult CheckRsaKeyGenParams(HcfAsyKeyGenSpiRsaParams *params) return HCF_INVALID_PARAMS; } break; - case OPENSSL_RSA_KEY_SIZE_8192: - if (params->primes > OPENSSL_RSA_PRIMES_SIZE_5 || params->primes < OPENSSL_RSA_PRIMES_SIZE_2) { - LOGE("Set invalid primes %d to Keygen bits %d.", params->primes, params->bits); - return HCF_INVALID_PARAMS; - } + case OPENSSL_RSA_KEY_SIZE_8192: // This keySize can use primes from 2 to 5. break; default: LOGE("The current bits %d is invalid.", params->bits); @@ -112,25 +95,6 @@ static HcfResult CheckRsaKeyGenParams(HcfAsyKeyGenSpiRsaParams *params) return HCF_SUCCESS; } -static HcfResult DuplicatePkAndSkFromRSA(const RSA *rsa, RSA **pubKey, RSA **priKey) -{ - if (rsa == NULL) { - LOGE("Rsa is NULL."); - return HCF_INVALID_PARAMS; - } - if (DuplicateRsa(rsa, false, pubKey) != HCF_SUCCESS) { - LOGE("Duplicate pubkey rsa fail"); - return HCF_ERR_CRYPTO_OPERATION; - } - if (DuplicateRsa(rsa, true, priKey) != HCF_SUCCESS) { - LOGE("Duplicate prikey rsa fail"); - RSA_free(*pubKey); - *pubKey = NULL; - return HCF_ERR_CRYPTO_OPERATION; - } - return HCF_SUCCESS; -} - static const char *GetOpensslPubkeyClass(void) { return OPENSSL_RSA_PUBKEY_CLASS; @@ -173,11 +137,14 @@ static void DestroyPriKey(HcfObjectBase *self) return; } HcfOpensslRsaPriKey *impl = (HcfOpensslRsaPriKey*)self; - if (impl->sk != NULL) { - RSA_free(impl->sk); - impl->sk = NULL; - } - HcfFree(impl); + RSA_free(impl->sk); + impl->sk = NULL; + HcfFree(self); +} + +static void DestroyKey(HcfObjectBase *self) +{ + LOGI("process DestroyKey"); } static void DestroyKeyPair(HcfObjectBase *self) @@ -191,60 +158,119 @@ static void DestroyKeyPair(HcfObjectBase *self) return; } HcfOpensslRsaKeyPair *impl = (HcfOpensslRsaKeyPair*)self; - OH_HCF_OBJ_DESTROY((HcfObjectBase *)impl->base.priKey); + DestroyPriKey((HcfObjectBase *)impl->base.priKey); impl->base.priKey = NULL; - OH_HCF_OBJ_DESTROY((HcfObjectBase *)impl->base.pubKey); + DestroyPubKey((HcfObjectBase *)impl->base.pubKey); impl->base.pubKey = NULL; HcfFree(self); } -static HcfResult RsaSaveKeyMaterial(const RSA *rsa, const uint32_t keySize, HcfBlob *key, bool needPrivate) +static HcfResult CopyMemFromBIO(BIO *bio, HcfBlob *outBlob) { - const uint32_t keyByteLen = keySize / OPENSSL_BITS_PER_BYTE; - const uint32_t rawMaterialLen = sizeof(KeyMaterialRsa) + keyByteLen * OPENSSL_RSA_KEYPAIR_CNT; - uint8_t *rawMaterial = (uint8_t *)HcfMalloc(rawMaterialLen, 0); - if (rawMaterial == NULL) { - LOGE("Malloc rawMaterial fail."); - return HCF_ERR_MALLOC; + if (bio == NULL || outBlob == NULL) { + LOGE("Invalid input."); + return HCF_INVALID_PARAMS; + } + int len = BIO_pending(bio); + if (len < 0) { + LOGE("Bio len less than 0."); + return HCF_INVALID_PARAMS; } - KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)rawMaterial; - keyMaterial->keySize = keySize; - uint8_t *tmp_buff = (uint8_t *)HcfMalloc(sizeof(uint8_t) * keyByteLen, 0); - if (tmp_buff == NULL) { - HcfFree(rawMaterial); + HcfBlob blob; + blob.len = len; + blob.data = (uint8_t *)HcfMalloc(sizeof(uint8_t) * len, 0); + if (blob.data == NULL) { + LOGE("Malloc mem for blob fail."); return HCF_ERR_MALLOC; } + if (BIO_read(bio, blob.data, blob.len) <= 0) { + LOGE("Bio read fail"); + HcfPrintOpensslError(); + HcfFree(blob.data); + return HCF_ERR_CRYPTO_OPERATION; + } + outBlob->len = blob.len; + outBlob->data = blob.data; + return HCF_SUCCESS; +} + +static HcfResult ConvertPubKeyFromX509(HcfBlob *x509Blob, RSA **rsa) +{ + uint8_t *temp = x509Blob->data; + RSA *tempRsa = d2i_RSA_PUBKEY(NULL, (const unsigned char **)&temp, x509Blob->len); + if (tempRsa == NULL) { + LOGE("d2i_RSA_PUBKEY fail."); + return HCF_ERR_CRYPTO_OPERATION; + } + *rsa = tempRsa; + return HCF_SUCCESS; +} + +static HcfResult ConvertPriKeyFromPKCS8(HcfBlob *pkcs8Blob, RSA **rsa) +{ + uint8_t *temp = pkcs8Blob->data; + EVP_PKEY *pKey = d2i_AutoPrivateKey(NULL, (const unsigned char **)&temp, pkcs8Blob->len); + if (pKey == NULL) { + LOGE("d2i_AutoPrivateKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + RSA *tmpRsa = EVP_PKEY_get1_RSA(pKey); + if (tmpRsa == NULL) { + LOGE("EVP_PKEY_get0_RSA fail"); + HcfPrintOpensslError(); + EVP_PKEY_free(pKey); + return HCF_ERR_CRYPTO_OPERATION; + } + *rsa = tmpRsa; + EVP_PKEY_free(pKey); + return HCF_SUCCESS; +} + +static HcfResult EncodePubKeyToX509(RSA *rsa, HcfBlob *returnBlob) +{ + unsigned char *tempData = NULL; + int len = i2d_RSA_PUBKEY(rsa, &tempData); + if (len <= 0) { + LOGE("i2d_RSA_PUBKEY fail"); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + returnBlob->data = tempData; + returnBlob->len = len; + return HCF_SUCCESS; +} + +static HcfResult EncodePriKeyToPKCS8(RSA *rsa, HcfBlob *returnBlob) +{ + EVP_PKEY *pKey = NewEvpPkeyByRsa(rsa, true); + if (pKey == NULL) { + LOGE("NewEvpPkeyByRsa fail."); + return HCF_ERR_CRYPTO_OPERATION; + } HcfResult ret = HCF_SUCCESS; - uint32_t offset = sizeof(*keyMaterial); - keyMaterial->nSize = (uint32_t)BN_bn2bin(RSA_get0_n(rsa), tmp_buff); - if (memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->nSize) != HCF_SUCCESS) { - LOGE("copy n fail"); + BIO *bio = BIO_new(BIO_s_mem()); + if (bio == NULL) { + LOGE("BIO new fail."); + HcfPrintOpensslError(); ret = HCF_ERR_CRYPTO_OPERATION; - goto ERR; + goto ERR2; } - offset += keyMaterial->nSize; - keyMaterial->eSize = (uint32_t)BN_bn2bin(RSA_get0_e(rsa), tmp_buff); - if (memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->eSize) != HCF_SUCCESS) { - LOGE("copy e fail"); + if (i2d_PKCS8PrivateKey_bio(bio, pKey, NULL, NULL, 0, NULL, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("i2b_PrivateKey_bio fail."); + HcfPrintOpensslError(); ret = HCF_ERR_CRYPTO_OPERATION; - goto ERR; + goto ERR1; } - offset += keyMaterial->eSize; - if (needPrivate) { - keyMaterial->dSize = (uint32_t)BN_bn2bin(RSA_get0_d(rsa), tmp_buff); - if (memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->dSize) != HCF_SUCCESS) { - LOGE("copy d fail"); - ret = HCF_ERR_CRYPTO_OPERATION; - goto ERR; - } + if (CopyMemFromBIO(bio, returnBlob) != HCF_SUCCESS) { + LOGE("CopyMemFromBIO fail."); + ret = HCF_ERR_CRYPTO_OPERATION; + goto ERR1; } - key->data = rawMaterial; - key->len = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize; - HcfFree(tmp_buff); - return HCF_SUCCESS; -ERR: - HcfFree(keyMaterial); - HcfFree(tmp_buff); +ERR1: + BIO_free_all(bio); +ERR2: + EVP_PKEY_free(pKey); return ret; } @@ -259,8 +285,7 @@ static HcfResult GetPubKeyEncoded(HcfKey *self, HcfBlob *returnBlob) return HCF_INVALID_PARAMS; } HcfOpensslRsaPubKey *impl = (HcfOpensslRsaPubKey *)self; - - return RsaSaveKeyMaterial(impl->pk, impl->bits, returnBlob, false); + return EncodePubKeyToX509(impl->pk, returnBlob); } static HcfResult GetPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob) @@ -275,31 +300,52 @@ static HcfResult GetPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob) return HCF_INVALID_PARAMS; } HcfOpensslRsaPriKey *impl = (HcfOpensslRsaPriKey *)self; + return EncodePriKeyToPKCS8(impl->sk, returnBlob); +} - return RsaSaveKeyMaterial(impl->sk, impl->bits, returnBlob, true); +static const char *GetPubKeyFormat(HcfKey *self) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return NULL; + } + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PUBKEY_CLASS)) { + return NULL; + } + return OPENSSL_RSA_PUBKEY_FORMAT; +} + +static const char *GetPriKeyFormat(HcfKey *self) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return NULL; + } + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PRIKEY_CLASS)) { + return NULL; + } + return OPENSSL_RSA_PRIKEY_FORMAT; } -static const char *GetKeyFormat(HcfKey *self) +static const char *GetPriKeyAlgorithm(HcfKey *self) { if (self == NULL) { LOGE("Invalid input parameter."); return NULL; } - if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PRIKEY_CLASS) - && !IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PUBKEY_CLASS)) { + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PRIKEY_CLASS)) { return NULL; } - return OPENSSL_RSA_KEY_FORMAT; + return OPENSSL_RSA_ALGORITHM; } -static const char *GetAlgorithm(HcfKey *self) +static const char *GetPubKeyAlgorithm(HcfKey *self) { if (self == NULL) { LOGE("Invalid input parameter."); return NULL; } - if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PRIKEY_CLASS) - && !IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PUBKEY_CLASS)) { + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_RSA_PUBKEY_CLASS)) { return NULL; } return OPENSSL_RSA_ALGORITHM; @@ -319,7 +365,7 @@ static void ClearPriKeyMem(HcfPriKey *self) ((HcfOpensslRsaPriKey *)self)->sk = NULL; } -static HcfResult PackPubKey(RSA *rsaPubKey, uint32_t bits, HcfOpensslRsaPubKey **retPubKey) +static HcfResult PackPubKey(RSA *rsaPubKey, HcfOpensslRsaPubKey **retPubKey) { if (retPubKey == NULL || rsaPubKey == NULL) { LOGE("Invalid params"); @@ -331,16 +377,16 @@ static HcfResult PackPubKey(RSA *rsaPubKey, uint32_t bits, HcfOpensslRsaPubKey * return HCF_ERR_MALLOC; } (*retPubKey)->pk = rsaPubKey; - (*retPubKey)->bits = bits; - (*retPubKey)->base.base.getAlgorithm = GetAlgorithm; + (*retPubKey)->bits = RSA_bits(rsaPubKey); + (*retPubKey)->base.base.getAlgorithm = GetPubKeyAlgorithm; (*retPubKey)->base.base.getEncoded = GetPubKeyEncoded; - (*retPubKey)->base.base.getFormat = GetKeyFormat; + (*retPubKey)->base.base.getFormat = GetPubKeyFormat; (*retPubKey)->base.base.base.getClass = GetOpensslPubkeyClass; - (*retPubKey)->base.base.base.destroy = DestroyPubKey; + (*retPubKey)->base.base.base.destroy = DestroyKey; return HCF_SUCCESS; } -static HcfResult PackPriKey(RSA *rsaPriKey, uint32_t bits, HcfOpensslRsaPriKey **retPriKey) +static HcfResult PackPriKey(RSA *rsaPriKey, HcfOpensslRsaPriKey **retPriKey) { if (retPriKey == NULL || rsaPriKey == NULL) { LOGE("Invalid params"); @@ -352,13 +398,32 @@ static HcfResult PackPriKey(RSA *rsaPriKey, uint32_t bits, HcfOpensslRsaPriKey * return HCF_ERR_MALLOC; } (*retPriKey)->sk = rsaPriKey; - (*retPriKey)->bits = bits; + (*retPriKey)->bits = RSA_bits(rsaPriKey); (*retPriKey)->base.clearMem = ClearPriKeyMem; - (*retPriKey)->base.base.getAlgorithm = GetAlgorithm; + (*retPriKey)->base.base.getAlgorithm = GetPriKeyAlgorithm; (*retPriKey)->base.base.getEncoded = GetPriKeyEncoded; - (*retPriKey)->base.base.getFormat = GetKeyFormat; + (*retPriKey)->base.base.getFormat = GetPriKeyFormat; (*retPriKey)->base.base.base.getClass = GetOpensslPrikeyClass; - (*retPriKey)->base.base.base.destroy = DestroyPriKey; + (*retPriKey)->base.base.base.destroy = DestroyKey; + return HCF_SUCCESS; +} + +static HcfResult DuplicatePkAndSkFromRSA(RSA *rsa, RSA **pubKey, RSA **priKey) +{ + if (rsa == NULL) { + LOGE("Rsa is NULL."); + return HCF_INVALID_PARAMS; + } + if (DuplicateRsa(rsa, false, pubKey) != HCF_SUCCESS) { + LOGE("Duplicate pubkey rsa fail"); + return HCF_ERR_CRYPTO_OPERATION; + } + if (DuplicateRsa(rsa, true, priKey) != HCF_SUCCESS) { + LOGE("Duplicate prikey rsa fail"); + RSA_free(*pubKey); + *pubKey = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } return HCF_SUCCESS; } @@ -383,12 +448,12 @@ static HcfResult PackKeyPair(RSA *rsa, uint32_t realBits, HcfOpensslRsaKeyPair * } HcfOpensslRsaPriKey *priKeyImpl = NULL; HcfOpensslRsaPubKey *pubKeyImpl = NULL; - ret = PackPubKey(pubKey, realBits, &pubKeyImpl); + ret = PackPubKey(pubKey, &pubKeyImpl); if (ret != HCF_SUCCESS) { LOGE("Pack pubKey fail."); goto ERR2; } - ret = PackPriKey(priKey, realBits, &priKeyImpl); + ret = PackPriKey(priKey, &priKeyImpl); if (ret != HCF_SUCCESS) { LOGE("Pack priKey fail."); goto ERR1; @@ -496,137 +561,15 @@ static void DestroyKeyGeneratorSpiImpl(HcfObjectBase *self) LOGI("DestroyKeyGeneratorSpiImpl end."); } -static HcfResult InitRsaKeyBuf(const KeyMaterialRsa *keyMaterial, HcfBlob *bufBlob) -{ - uint32_t maxSize; - if (keyMaterial->nSize >= keyMaterial->eSize) { - maxSize = keyMaterial->nSize; - } else { - maxSize = keyMaterial->eSize; - } - - if (maxSize < keyMaterial->dSize) { - maxSize = keyMaterial->dSize; - } - - bufBlob->data = (uint8_t *)HcfMalloc(maxSize, 0); - if (bufBlob->data == NULL) { - LOGE("HcfMalloc failed!"); - return HCF_ERR_MALLOC; - } - bufBlob->len = maxSize; - return HCF_SUCCESS; -} - -static HcfResult ParseRsaBnFromBin(const HcfBlob *key, BIGNUM **n, BIGNUM **e, BIGNUM **d, const bool needPrivate) -{ - const KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)(key->data); - HcfBlob bufBlob = { .len = 0, .data = NULL }; - HcfResult ret = InitRsaKeyBuf(keyMaterial, &bufBlob); - if (ret != HCF_SUCCESS) { - return ret; - } - ret = HCF_SUCCESS; - do { - uint32_t offset = sizeof(*keyMaterial); - if (memcpy_s(bufBlob.data, bufBlob.len, key->data + offset, keyMaterial->nSize) != HCF_SUCCESS) { - LOGE("memcpy_s n bin data fail"); - ret = HCF_ERR_COPY; - break; - } - *n = BN_bin2bn(bufBlob.data, keyMaterial->nSize, NULL); - offset += keyMaterial->nSize; - if (memcpy_s(bufBlob.data, bufBlob.len, key->data + offset, keyMaterial->eSize) != HCF_SUCCESS) { - LOGE("memcpy_s e bin data fail"); - ret = HCF_ERR_COPY; - break; - } - *e = BN_bin2bn(bufBlob.data, keyMaterial->eSize, NULL); - offset += keyMaterial->eSize; - *d = NULL; - if (needPrivate) { - if (memcpy_s(bufBlob.data, bufBlob.len, key->data + offset, keyMaterial->dSize) != HCF_SUCCESS) { - LOGE("memcpy_s d bin data fail"); - ret = HCF_ERR_COPY; - break; - } - *d = BN_bin2bn(bufBlob.data, keyMaterial->dSize, NULL); - } - } while (0); - if (memset_s(bufBlob.data, bufBlob.len, 0, - (((keyMaterial->keySize) + OPENSSL_BITS_PER_BYTE - 1) / OPENSSL_BITS_PER_BYTE)) != HCF_SUCCESS) { - LOGE("memset bufBlob fail. possibly leaving sensitive information."); - } - HcfFree(bufBlob.data); - return ret; -} - -static RSA *InitRsaStructByBin(const HcfBlob *key, const bool needPrivateExponent) -{ - BIGNUM *n = NULL; - BIGNUM *e = NULL; - BIGNUM *d = NULL; - - RSA *rsa = NULL; - do { - if (ParseRsaBnFromBin(key, &n, &e, &d, needPrivateExponent) != HCF_SUCCESS) { - LOGE("ParseRsaBnFromBin fail"); - break; - } - rsa = RSA_new(); - if (rsa != NULL) { - if (RSA_set0_key(rsa, n, e, d) != HCF_OPENSSL_SUCCESS) { - LOGE("set rsa Bn fail"); - HcfPrintOpensslError(); - RSA_free(rsa); - rsa = NULL; - break; - } - } - } while (0); - - if (rsa == NULL) { - BN_clear_free(n); - BN_clear_free(e); - BN_clear_free(d); - } - - return rsa; -} - -static HcfResult RsaCheckKeyMaterial(const HcfBlob *key) -{ - const KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)(key->data); - if ((keyMaterial->keySize < MIN_KEY_SIZE) || (keyMaterial->keySize > MAX_KEY_SIZE)) { - LOGE("Input keySize is invalid"); - return HCF_INVALID_PARAMS; - } - if (key->len != sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize) { - LOGE("Input len dismatch with data"); - return HCF_INVALID_PARAMS; - } - return HCF_SUCCESS; -} - static HcfResult ConvertPubKey(HcfBlob *pubKeyBlob, HcfOpensslRsaPubKey **pubkeyRet) { - if ((pubKeyBlob == NULL) || (pubKeyBlob->data == NULL)) { - LOGE("PubKeyBlob is NULL."); - return HCF_INVALID_PARAMS; - } - if (RsaCheckKeyMaterial(pubKeyBlob) != HCF_SUCCESS) { - LOGE("check input key material fail"); - return HCF_INVALID_PARAMS; - } - - RSA *rsaPk = InitRsaStructByBin(pubKeyBlob, false); - if (rsaPk == NULL) { - LOGE("Init rsaPk fail."); - return HCF_ERR_MALLOC; + RSA *rsaPk = NULL; + if (ConvertPubKeyFromX509(pubKeyBlob, &rsaPk) != HCF_SUCCESS) { + LOGE("Convert pubKey from X509 fail."); + return HCF_ERR_CRYPTO_OPERATION; } - KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)(pubKeyBlob->data); HcfOpensslRsaPubKey *pubKey = NULL; - HcfResult ret = PackPubKey(rsaPk, keyMaterial->keySize, &pubKey); + HcfResult ret = PackPubKey(rsaPk, &pubKey); if (ret != HCF_SUCCESS) { LOGE("PackPubKey fail"); goto ERR; @@ -640,22 +583,13 @@ ERR: static HcfResult ConvertPriKey(HcfBlob *priKeyBlob, HcfOpensslRsaPriKey **priKeyRet) { - if (priKeyBlob == NULL || priKeyBlob->data == NULL) { - LOGE("PriKeyBlob is NULL."); - return HCF_INVALID_PARAMS; - } - if (RsaCheckKeyMaterial(priKeyBlob) != HCF_SUCCESS) { - LOGE("check input key material fail"); - return HCF_INVALID_PARAMS; - } - RSA *rsaSk = InitRsaStructByBin(priKeyBlob, true); - if (rsaSk == NULL) { - LOGE("Init rsaSk fail."); + RSA *rsaSk = NULL; + if (ConvertPriKeyFromPKCS8(priKeyBlob, &rsaSk) != HCF_SUCCESS) { + LOGE("ConvertPriKeyFromPKCS8 fail."); return HCF_ERR_MALLOC; } - KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)(priKeyBlob->data); HcfOpensslRsaPriKey *priKey = NULL; - HcfResult ret = PackPriKey(rsaSk, keyMaterial->keySize, &priKey); + HcfResult ret = PackPriKey(rsaSk, &priKey); if (ret != HCF_SUCCESS) { LOGE("PackPriKey fail"); goto ERR; @@ -693,7 +627,7 @@ static HcfResult EngineConvertKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *pa if (priKeyBlob != NULL && priKeyBlob->data != NULL) { if (ConvertPriKey(priKeyBlob, &priKey) != HCF_SUCCESS) { LOGE("convert prikey fail."); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)pubKey); + HcfObjDestroy((HcfObjectBase *)pubKey); return HCF_INVALID_PARAMS; } } @@ -701,8 +635,8 @@ static HcfResult EngineConvertKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *pa HcfOpensslRsaKeyPair *keyPair = (HcfOpensslRsaKeyPair *)HcfMalloc(sizeof(HcfOpensslRsaKeyPair), 0); if (keyPair == NULL) { LOGE("Malloc keyPair fail."); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)pubKey); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)priKey); + HcfObjDestroy((HcfObjectBase *)pubKey); + HcfObjDestroy((HcfObjectBase *)priKey); return HCF_ERR_MALLOC; } diff --git a/plugin/openssl_plugin/key/sym_key_generator/inc/sym_common_defines.h b/plugin/openssl_plugin/key/sym_key_generator/inc/sym_common_defines.h index 71cd093a314b1b5c50d0367c6a4b9595169b3e3c..ec8d3a0b4c3648b340812ecf601154e3551dc77f 100644 --- a/plugin/openssl_plugin/key/sym_key_generator/inc/sym_common_defines.h +++ b/plugin/openssl_plugin/key/sym_key_generator/inc/sym_common_defines.h @@ -35,7 +35,7 @@ typedef struct { extern "C" { #endif -HcfResult HcfSymKeyGeneratorSpiCreate(SymKeyAttr *attr, OH_HCF_SymKeyGeneratorSpi **genertor); +HcfResult HcfSymKeyGeneratorSpiCreate(SymKeyAttr *attr, HcfSymKeyGeneratorSpi **generator); #ifdef __cplusplus } diff --git a/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c b/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c index 05598cac0e622c151ec8bb37cc26a12968bcdbdb..958059022a4c379fee70f4e0b6c775e0eaecd9ce 100644 --- a/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c +++ b/plugin/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c @@ -29,7 +29,7 @@ #define DES_ALG_NAME "3DES" typedef struct { - OH_HCF_SymKeyGeneratorSpi base; + HcfSymKeyGeneratorSpi base; SymKeyAttr attr; } HcfSymKeyGeneratorSpiOpensslImpl; @@ -58,6 +58,22 @@ static HcfResult GetEncoded(HcfKey *self, HcfBlob *key) return HCF_SUCCESS; } +static void ClearMem(HcfSymKey *self) +{ + if (self == NULL) { + LOGE("symKey is NULL."); + return; + } + if (!IsClassMatch((const HcfObjectBase *)self, OPENSSL_SYM_KEY_CLASS)) { + LOGE("Class is not match."); + return; + } + SymKeyImpl *impl = (SymKeyImpl *)self; + if ((impl->keyMaterial.data != NULL) && (impl->keyMaterial.len > 0)) { + (void)memset_s(impl->keyMaterial.data, impl->keyMaterial.len, 0, impl->keyMaterial.len); + } +} + static const char *GetFormat(HcfKey *self) { if (self == NULL) { @@ -103,7 +119,7 @@ static HcfResult RandomSymmKey(int32_t keyLen, HcfBlob *symmKey) LOGE("keyMaterial malloc failed!"); return HCF_ERR_MALLOC; } - int ret = RAND_bytes(keyMaterial, keyLen); + int ret = RAND_priv_bytes(keyMaterial, keyLen); if (ret != HCF_OPENSSL_SUCCESS) { LOGE("RAND_bytes failed!"); HcfPrintOpensslError(); @@ -227,7 +243,7 @@ static HcfResult CopySymmKey(const HcfBlob *srcKey, HcfBlob *dstKey) return HCF_SUCCESS; } -static HcfResult GenerateSymmKey(OH_HCF_SymKeyGeneratorSpi *self, HcfSymKey **symmKey) +static HcfResult GenerateSymmKey(HcfSymKeyGeneratorSpi *self, HcfSymKey **symmKey) { if ((self == NULL) || (symmKey == NULL)) { LOGE("Invalid input parameter!"); @@ -249,6 +265,7 @@ static HcfResult GenerateSymmKey(OH_HCF_SymKeyGeneratorSpi *self, HcfSymKey **sy return res; } returnSymmKey->algoName = GetAlgoName(impl); + returnSymmKey->key.clearMem = ClearMem; returnSymmKey->key.key.getEncoded = GetEncoded; returnSymmKey->key.key.getFormat = GetFormat; returnSymmKey->key.key.getAlgorithm = GetAlgorithm; @@ -258,7 +275,7 @@ static HcfResult GenerateSymmKey(OH_HCF_SymKeyGeneratorSpi *self, HcfSymKey **sy return HCF_SUCCESS; } -static HcfResult ConvertSymmKey(OH_HCF_SymKeyGeneratorSpi *self, const HcfBlob *key, HcfSymKey **symmKey) +static HcfResult ConvertSymmKey(HcfSymKeyGeneratorSpi *self, const HcfBlob *key, HcfSymKey **symmKey) { if ((self == NULL) || (symmKey == NULL) || !IsBlobValid(key)) { LOGE("Invalid input parameter."); @@ -286,6 +303,7 @@ static HcfResult ConvertSymmKey(OH_HCF_SymKeyGeneratorSpi *self, const HcfBlob * return res; } returnSymmKey->algoName = GetAlgoName(impl); + returnSymmKey->key.clearMem = ClearMem; returnSymmKey->key.key.getEncoded = GetEncoded; returnSymmKey->key.key.getFormat = GetFormat; returnSymmKey->key.key.getAlgorithm = GetAlgorithm; @@ -295,7 +313,7 @@ static HcfResult ConvertSymmKey(OH_HCF_SymKeyGeneratorSpi *self, const HcfBlob * return HCF_SUCCESS; } -HcfResult HcfSymKeyGeneratorSpiCreate(SymKeyAttr *attr, OH_HCF_SymKeyGeneratorSpi **generator) +HcfResult HcfSymKeyGeneratorSpiCreate(SymKeyAttr *attr, HcfSymKeyGeneratorSpi **generator) { if ((attr == NULL) || (generator == NULL)) { LOGE("Invalid input parameter."); @@ -312,7 +330,7 @@ HcfResult HcfSymKeyGeneratorSpiCreate(SymKeyAttr *attr, OH_HCF_SymKeyGeneratorSp returnGenerator->base.engineConvertSymmKey = ConvertSymmKey; returnGenerator->base.base.destroy = DestroySymKeyGeneratorSpi; returnGenerator->base.base.getClass = GetSymKeyGeneratorClass; - *generator = (OH_HCF_SymKeyGeneratorSpi *)returnGenerator; + *generator = (HcfSymKeyGeneratorSpi *)returnGenerator; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index da411b657ff977f16a270d93dd1c918ffb89a0ff..91c0a3b6469af7fc6ae8b6c5c14b791b21a60d00 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -34,8 +34,8 @@ static const char *GetRandOpenSSLClass(void) static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBlob *random) { - unsigned char rand_buf[numBytes]; - int32_t ret = RAND_bytes(rand_buf, numBytes); + unsigned char randBuf[numBytes]; + int32_t ret = RAND_priv_bytes(randBuf, numBytes); if (ret != HCF_OPENSSL_SUCCESS) { LOGE("RAND_bytes return error!"); HcfPrintOpensslError(); @@ -46,26 +46,14 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl LOGE("Failed to allocate random->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(random->data, numBytes, rand_buf, numBytes) != EOK) { - LOGE("memcpy error!"); - HcfFree(random->data); - random->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(random->data, numBytes, randBuf, numBytes); random->len = numBytes; return HCF_SUCCESS; } -static HcfResult OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) +static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { - int32_t seedLen = seed->len; - unsigned char seedBuf[seedLen]; - if (memcpy_s(seedBuf, seedLen, seed->data, seedLen) != EOK) { - LOGE("memcpy error!"); - return HCF_ERR_COPY; - } - RAND_seed(seedBuf, seedLen); - return HCF_SUCCESS; + RAND_seed(seed->data, seed->len); } static void DestroyRandOpenssl(HcfObjectBase *self) diff --git a/plugin/plugin.gni b/plugin/plugin.gni index 245b7cf160234225f6483dff5e561acd612564d2..84947f6c78f80444bd7f5fd2000050fe79979f86 100644 --- a/plugin/plugin.gni +++ b/plugin/plugin.gni @@ -17,7 +17,6 @@ plugin_path = "//base/security/crypto_framework/plugin" plugin_inc_path = [ "${base_path}/interfaces/innerkits/common", - "${plugin_path}/openssl_plugin/certificate/inc", "${plugin_path}/openssl_plugin/common/inc", "${plugin_path}/openssl_plugin/key/asy_key_generator/inc", "${plugin_path}/openssl_plugin/key/sym_key_generator/inc", @@ -38,6 +37,7 @@ plugin_signature_files = [ ] plugin_common_files = [ + "${plugin_path}/openssl_plugin/common/src/openssl_adapter.c", "${plugin_path}/openssl_plugin/common/src/openssl_common.c", "${plugin_path}/openssl_plugin/common/src/rsa_openssl_common.c", ] @@ -49,13 +49,6 @@ plugin_asy_key_generator_files = [ plugin_key_agreement_files = [ "${plugin_path}/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c" ] -plugin_certificate_files = [ - "${plugin_path}/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c", - "${plugin_path}/openssl_plugin/certificate/src/x509_certificate_openssl.c", - "${plugin_path}/openssl_plugin/certificate/src/x509_crl_openssl.c", - "${plugin_path}/openssl_plugin/certificate/src/x509_crl_entry_openssl.c", -] - plugin_sym_key_files = [ "${plugin_path}/openssl_plugin/key/sym_key_generator/src/sym_key_openssl.c", ] @@ -75,7 +68,7 @@ plugin_rand_files = [ "${plugin_path}/openssl_plugin/rand/src/rand_openssl.c" ] plugin_md_files = [ "${plugin_path}/openssl_plugin/crypto_operation/md/src/md_openssl.c" ] -plugin_files = plugin_certificate_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_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 diff --git a/test/fuzztest/certificate/x509certificate_fuzzer/BUILD.gn b/test/fuzztest/certificate/x509certificate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..3a19b37ec6d44a1892ca25906c82cf57e628337c --- /dev/null +++ b/test/fuzztest/certificate/x509certificate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/certificate" + +##############################fuzztest########################################## +ohos_fuzztest("X509CertificateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/certificate/x509certificate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "x509certificate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":X509CertificateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/certificate/x509certificate_fuzzer/corpus/init b/test/fuzztest/certificate/x509certificate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/certificate/x509certificate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/certificate/x509certificate_fuzzer/project.xml b/test/fuzztest/certificate/x509certificate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/certificate/x509certificate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.cpp b/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..3a74d77b8e357a1c239d1866402de6c64eaf1539 --- /dev/null +++ b/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2022 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 "x509certificate_fuzzer.h" + +#include +#include +#include "securec.h" + +#include "blob.h" +#include "result.h" +#include "x509_certificate.h" + +namespace OHOS { + static char g_fuzzCert[] = + "-----BEGIN CERTIFICATE-----\r\n" + "MIIEMjCCAxqgAwIBAgICARAwDQYJKoZIhvcNAQELBQAwdjELMAkGA1UEBhMCQ04x\r\n" + "CzAJBgNVBAgMAkJKMQswCQYDVQQHDAJCSjELMAkGA1UECgwCSEQxDDAKBgNVBAsM\r\n" + "A2RldjELMAkGA1UEAwwCY2ExJTAjBgkqhkiG9w0BCQEWFmNhQGNyeXB0b2ZyYW1l\r\n" + "d29yay5jb20wHhcNMjIwODE5MTI0OTA2WhcNMzIwODE2MTI0OTA2WjB2MQswCQYD\r\n" + "VQQGEwJDTjELMAkGA1UECAwCQkoxCzAJBgNVBAcMAkJKMQswCQYDVQQKDAJIRDEM\r\n" + "MAoGA1UECwwDZGV2MQswCQYDVQQDDAJjYTElMCMGCSqGSIb3DQEJARYWY2FAY3J5\r\n" + "cHRvZnJhbWV3b3JrLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\r\n" + "AJ8p0IWE7WwwbtATg+AbYQj33WNBBktU+/AVf+Tl1aAa4TOeW2/ZARc4sdwLVTxd\r\n" + "XCipFseuiGN30hwXrXFUHrcMf0w2sCkznJVZ/rQcfEO5Kb1vBz6DEEcgISYEhhqO\r\n" + "BfYBit5qfpq5R2+2R/Th/ybV+kBrUl+GssXbDAe6oZCy56lGphDvmHMUO7a13j+S\r\n" + "FmThMbI2yeyua1LagSoaBJfY1J+i7jWPmmEFR0dQ2p0EGjHTgQGhRo5VuwDHipNS\r\n" + "v0XP8OUA/PYbL/SBj1Fq4C3gtfvjeswUbzVaMoq/wCuy1qcXI80ZLe3whR24c0cX\r\n" + "YFO0uGi9egPp24fw7yYGqgECAwEAAaOByTCBxjAdBgNVHQ4EFgQUjKM7QmMBs01R\r\n" + "9uQttYN/GDkvt7UwHwYDVR0jBBgwFoAUjKM7QmMBs01R9uQttYN/GDkvt7UwEgYD\r\n" + "VR0TAQH/BAgwBgEB/wIBAjALBgNVHQ8EBAMCAQYwHQYDVR0lBBYwFAYIKwYBBQUH\r\n" + "AwEGCCsGAQUFBwMCMCEGA1UdEQQaMBiBFmNhQGNyeXB0b2ZyYW1ld29yay5jb20w\r\n" + "IQYDVR0SBBowGIEWY2FAY3J5cHRvZnJhbWV3b3JrLmNvbTANBgkqhkiG9w0BAQsF\r\n" + "AAOCAQEAh+4RE6cJ62/gLYssLkc7ESg7exKwZlmisHyBicuy/+XagOZ3cTbgQNXl\r\n" + "QoZKbw/ks/B/cInbQGYbpAm47Sudo+I/G9xj0X7gQB9wtSrbStOs6SjnLiYU0xFc\r\n" + "Fsc0j6k2SrlyiwRQcjS4POKiUS0Cm3F3DHGdj55PlBkXxudXCq2V3J3VwKf2bVjQ\r\n" + "bzz2+M/Q1m+P7FhB+JmeO8eemkqMQ0tFMU3EM441NpejC5iFVAGgownC8S0B+fxH\r\n" + "9dBJuHM6vpxEWw3ckZFDZQ1kd91YRgr7jY8fc0v/T0tzHWbOEVzklEIBWL1mompL\r\n" + "BCwe0/Gw+BO60bfi2MoJw8t2IcB1Qw==\r\n" + "-----END CERTIFICATE-----\r\n"; + + static bool g_testFlag = true; + + static void TestGetEncoded(HcfX509Certificate *x509CertObj) + { + HcfEncodingBlob derBlob = { 0 }; + HcfResult res = x509CertObj->base.getEncoded(&(x509CertObj->base), &derBlob); + if (res != HCF_SUCCESS) { + return; + } + free(derBlob.data); + } + + static void TestVerify(HcfX509Certificate *x509CertObj) + { + HcfPubKey *keyOut = nullptr; + HcfResult res = x509CertObj->base.getPublicKey(&(x509CertObj->base), &keyOut); + if (res != HCF_SUCCESS) { + return; + } + (void)x509CertObj->base.verify(&(x509CertObj->base), keyOut); + HcfObjDestroy(keyOut); + } + + static void TestQuery(HcfX509Certificate *x509CertObj) + { + HcfBlob sn = { 0 }; + (void)x509CertObj->getSerialNumber(x509CertObj, &sn); + HcfBlobDataClearAndFree(&sn); + + HcfBlob issuerName = { 0 }; + (void)x509CertObj->getIssuerName(x509CertObj, &issuerName); + HcfBlobDataClearAndFree(&issuerName); + + HcfBlob subjectName = { 0 }; + (void)x509CertObj->getSubjectName(x509CertObj, &subjectName); + HcfBlobDataClearAndFree(&subjectName); + + HcfBlob notBeforeTime = { 0 }; + (void)x509CertObj->getNotBeforeTime(x509CertObj, ¬BeforeTime); + HcfBlobDataClearAndFree(¬BeforeTime); + + HcfBlob notAfterTime = { 0 }; + (void)x509CertObj->getNotAfterTime(x509CertObj, ¬AfterTime); + HcfBlobDataClearAndFree(¬AfterTime); + + HcfBlob sigOut = { 0 }; + (void)x509CertObj->getSignature(x509CertObj, &sigOut); + HcfBlobDataClearAndFree(&sigOut); + + HcfBlob sigAlgOid = { 0 }; + (void)x509CertObj->getSignatureAlgOid(x509CertObj, &sigAlgOid); + HcfBlobDataClearAndFree(&sigAlgOid); + + HcfBlob sigAlgParamsOut = { 0 }; + (void)x509CertObj->getSignatureAlgParams(x509CertObj, &sigAlgParamsOut); + HcfBlobDataClearAndFree(&sigAlgParamsOut); + + HcfArray keyUsageOut = { 0 }; + (void)x509CertObj->getExtKeyUsage(x509CertObj, &keyUsageOut); + HcfArrayDataClearAndFree(&keyUsageOut); + + int32_t pathLen = x509CertObj->getBasicConstraints(x509CertObj); + if (pathLen < 0) { + return; + } + HcfArray subjectAltName = { 0 }; + (void)x509CertObj->getSubjectAltNames(x509CertObj, &subjectAltName); + HcfArrayDataClearAndFree(&subjectAltName); + } + + static void CreateOneCert(void) + { + HcfEncodingBlob inStream = { 0 }; + inStream.data = reinterpret_cast(g_fuzzCert); + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = strlen(g_fuzzCert) + 1; + HcfX509Certificate *x509CertObj = nullptr; + HcfResult res = HcfX509CertificateCreate(&inStream, &x509CertObj); + if (res != HCF_SUCCESS) { + return; + } + TestGetEncoded(x509CertObj); + TestVerify(x509CertObj); + TestQuery(x509CertObj); + } + + bool X509CertificateFuzzTest(const uint8_t* data, size_t size) + { + if (g_testFlag) { + CreateOneCert(); + g_testFlag = false; + } + if (data == nullptr) { + return false; + } + HcfEncodingBlob inStream = { 0 }; + inStream.data = const_cast(data); + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = size; + HcfX509Certificate *x509CertObj = nullptr; + HcfResult res = HcfX509CertificateCreate(&inStream, &x509CertObj); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(x509CertObj); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::X509CertificateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.h b/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..faee4901991675bd09dd1689d797b130ae9ae22e --- /dev/null +++ b/test/fuzztest/certificate/x509certificate_fuzzer/x509certificate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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 X509_CERTIFICATE_FUZZER_H +#define X509_CERTIFICATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "x509certificate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/certificate/x509crl_fuzzer/BUILD.gn b/test/fuzztest/certificate/x509crl_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..53fd7b31b3207ea3125fb3999586d93072aa44bb --- /dev/null +++ b/test/fuzztest/certificate/x509crl_fuzzer/BUILD.gn @@ -0,0 +1,67 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/certificate" + +##############################fuzztest########################################## +ohos_fuzztest("X509CrlFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/certificate/x509crl_fuzzer" + include_dirs = [ + "//commonlibrary/c_utils/base/include", + "//third_party/openssl/include", + ] + include_dirs += framework_inc_path + include_dirs += [ + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/inc", + ] + sources = [ "x509crl_fuzzer.cpp" ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-DHILOG_ENABLE", + ] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//third_party/openssl:libcrypto_shared", + ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":X509CrlFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/certificate/x509crl_fuzzer/corpus/init b/test/fuzztest/certificate/x509crl_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..8eb5a7d6eb6b7d71f0c70c244e5768d62bee6ac5 --- /dev/null +++ b/test/fuzztest/certificate/x509crl_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2022 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. + */ + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/certificate/x509crl_fuzzer/project.xml b/test/fuzztest/certificate/x509crl_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/certificate/x509crl_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.cpp b/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..21ce5f65b39cf1fac8bca51b6056103174cf06f5 --- /dev/null +++ b/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.cpp @@ -0,0 +1,327 @@ +/* + * Copyright (c) 2022 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 "x509crl_fuzzer.h" +#include +#include "asy_key_generator.h" +#include "blob.h" +#include "cipher.h" +#include "key_pair.h" +#include "memory.h" +#include "certificate_openssl_class.h" +#include "result.h" +#include "securec.h" +#include "x509_certificate.h" +#include "x509_crl.h" +#include "x509_crl_entry.h" + +namespace OHOS { + constexpr int TEST_VERSION = 3; + constexpr int TEST_OFFSET_TIME = 1000; + constexpr int TEST_SN = 1000; + constexpr int TEST_TIME = 1986598400; + constexpr int TEST_OFFSET = 10; + constexpr int TEST_CRL_LEN = 256; + + HcfKeyPair *g_keyPair = nullptr; + ASN1_TIME *g_lastUpdate = nullptr; + ASN1_TIME *g_nextUpdate = nullptr; + ASN1_TIME *g_rvTime = nullptr; + + static char g_testCrl[] = + "-----BEGIN X509 CRL-----\r\n" + "MIIB/DCB5QIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04xETAPBgNV\r\n" + "BAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3dy50ZXN0\r\n" + "LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29tMRwwGgYJ\r\n" + "KoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tFw0yMjA4MjkwNzAwMTRaFw0yMjA5Mjgw\r\n" + "NzAwMTRaMBQwEgIBARcNMjIwODI5MDY1OTUzWqAOMAwwCgYDVR0UBAMCAQAwDQYJ\r\n" + "KoZIhvcNAQELBQADggEBAHpfFhhUR59OAvOSuKDQUC5tKeLEuPbY8bYdmQVI8EFd\r\n" + "xDkZTXmT3CX1aDPYKVsG/jH9KPAmCV/ODKEGiJzclb3Z4am7tT+Wy4mpXypNS1od\r\n" + "wPDcQGsMrjT6iSp6JImiB0dDDSleBTBcYR/hhtFaiGSncyqJ0mhyaXPxIkNOO6nY\r\n" + "v+rcTEPQWavViDRyNDhnTbN868I3fzFVBcidF13CA0sCJ91ZvsE9h/YmPO2+e0YE\r\n" + "IUgzn37UOiLGObCVBY12QjGiuvVvCl7ncncsFEJuGfvONOqyFHjyxDHo5W0fqTn2\r\n" + "eCtiNcgUr9Kz2bwCmvEXhP7PuF4RMLq4vfzi0YjCG98=\r\n" + "-----END X509 CRL-----\r\n"; + + static char g_testCert[] = + "-----BEGIN CERTIFICATE-----\r\n" + "MIID/jCCAuagAwIBAgIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04x\r\n" + "ETAPBgNVBAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3\r\n" + "dy50ZXN0LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29t\r\n" + "MRwwGgYJKoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tMB4XDTIyMDgyOTA2NTUwM1oX\r\n" + "DTIzMDgyOTA2NTUwM1owezELMAkGA1UEBhMCQ04xETAPBgNVBAgMCHNoYW5naGFp\r\n" + "MRUwEwYDVQQKDAx3d3cudGVzdC5jb20xDTALBgNVBAsMBHRlc3QxFTATBgNVBAMM\r\n" + "DHd3dy50ZXN0LmNvbTEcMBoGCSqGSIb3DQEJARYNdGVzdEB0ZXN0LmNvbTCCASIw\r\n" + "DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJmY9T4SzXXwKvfMvnvMWY7TqUJK\r\n" + "jnWf2Puv0YUQ2fdvyoKQ2LQXdtzoUL53j587oI+IXelOr7dg020zPyun0cmZHZ4y\r\n" + "l/qAcrWbDjZeEGcbbb5UtQtn1WOEnv8pkXluO355mbZQUKK9L3gFWseXJKGbIXw0\r\n" + "NRpaJZzqvPor4m3a5pmJKPHOlivUdYfLaKSkNj3DlaFzCWKV82k5ee6gzVyETtG+\r\n" + "XN+vq8qLybT+fIFsLNMmAHzRxlqz3NiH7yh+1/p/Knvf8bkkRVR2btH51RyX2RSu\r\n" + "DjPM0/VRL8fxDSDeWBq+Gvn/E6AbOVMmkx63tcyWHhklCSaZtyz7kq39TQMCAwEA\r\n" + "AaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0\r\n" + "ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFFiFDysfADQCzRZCOSPupQxFicwzMB8G\r\n" + "A1UdIwQYMBaAFNYQRQiPsG8HefOTsmsVhaVjY7IPMA0GCSqGSIb3DQEBCwUAA4IB\r\n" + "AQAeppxf6sKQJxJQXKPTT3xHKaskidNwDBbOSIvnVvWXicZXDs+1sF6tUaRgvPxL\r\n" + "OL58+P2Jy0tfSwj2WhqQRGe9MvQ5iFHcdelZc0ciW6EQ0VDHIaDAQc2nQzej/79w\r\n" + "UE7BJJV3b9n1be2iCsuodKO14pOkMb84WcIxng+8SD+MiFqV5BPO1QyKGdO1PE1b\r\n" + "+evjyTpFSTgZf2Mw3fGtu5hfEXyHw1lnsFY2MlSwiRlAym/gm4aXy+4H6LyXKd56\r\n" + "UYQ6fituD0ziaw3RI6liyIe7aENHCkZf6bAvMRhk4QiU4xu6emwX8Qt1bT7RthP0\r\n" + "1Vsro0IOeXT9WAcqEtQUegsi\r\n" + "-----END CERTIFICATE-----\r\n"; + + static void FreeCrlData() + { + if (g_keyPair != nullptr) { + HcfObjDestroy(g_keyPair); + g_keyPair = nullptr; + } + if (g_lastUpdate != nullptr) { + ASN1_TIME_free(g_lastUpdate); + g_lastUpdate = nullptr; + } + if (g_nextUpdate != nullptr) { + ASN1_TIME_free(g_nextUpdate); + g_nextUpdate = nullptr; + } + if (g_rvTime != nullptr) { + ASN1_TIME_free(g_rvTime); + g_rvTime = nullptr; + } + } + + static unsigned char *GetCrlStream() + { + unsigned char *buf, *p; + HcfAsyKeyGenerator *generator = nullptr; + HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator); + generator->generateKeyPair(generator, nullptr, &g_keyPair); + RSA *rsaPrikey = (reinterpret_cast(g_keyPair->priKey))->sk; + EVP_PKEY *prikey = EVP_PKEY_new(); + EVP_PKEY_assign_RSA(prikey, rsaPrikey); + + X509_CRL *crl = X509_CRL_new(); + (void)X509_CRL_set_version(crl, TEST_VERSION); + + // Set Issuer + X509_NAME *issuer = X509_NAME_new(); + const char *tmp = "CRL issuer"; + (void)X509_NAME_add_entry_by_NID(issuer, NID_commonName, V_ASN1_PRINTABLESTRING, + reinterpret_cast(tmp), 10, -1, 0); + (void)X509_CRL_set_issuer_name(crl, issuer); + + g_lastUpdate = ASN1_TIME_new(); + time_t t = time(nullptr); + ASN1_TIME_set(g_lastUpdate, t + TEST_OFFSET_TIME); + (void)X509_CRL_set_lastUpdate(crl, g_lastUpdate); + + g_nextUpdate = ASN1_TIME_new(); + t = TEST_TIME; + ASN1_TIME_set(g_nextUpdate, t); + (void)X509_CRL_set_nextUpdate(crl, g_nextUpdate); + + X509_REVOKED *revoked = X509_REVOKED_new(); + ASN1_INTEGER *serial = ASN1_INTEGER_new(); + (void)ASN1_INTEGER_set(serial, TEST_SN); + (void)X509_REVOKED_set_serialNumber(revoked, serial); + + g_rvTime = ASN1_TIME_new(); + t = TEST_TIME; + ASN1_TIME_set(g_rvTime, t); + (void)X509_CRL_set_nextUpdate(crl, g_rvTime); + (void)X509_REVOKED_set_revocationDate(revoked, g_rvTime); + (void)X509_CRL_add0_revoked(crl, revoked); + + (void)X509_CRL_sort(crl); + (void)X509_CRL_sign(crl, prikey, EVP_md5()); + int len = i2d_X509_CRL(crl, nullptr); + buf = reinterpret_cast(malloc(len + TEST_OFFSET)); + p = buf; + (void)i2d_X509_CRL(crl, &p); + return buf; + } + + static void TestX509CrlPem(HcfX509Crl *x509CrlPem) + { + HcfEncodingBlob encodingBlob = { 0 }; + (void)x509CrlPem->getEncoded(x509CrlPem, &encodingBlob); + if (encodingBlob.data != nullptr) { + HcfFree(encodingBlob.data); + } + HcfBlob issuerName = { 0 }; + (void)x509CrlPem->getIssuerName(x509CrlPem, &issuerName); + if (issuerName.data != nullptr) { + HcfFree(issuerName.data); + } + HcfBlob lastUpdate = { 0 }; + (void)x509CrlPem->getLastUpdate(x509CrlPem, &lastUpdate); + if (lastUpdate.data != nullptr) { + HcfFree(lastUpdate.data); + } + HcfBlob nextUpdate = { 0 }; + (void)x509CrlPem->getNextUpdate(x509CrlPem, &nextUpdate); + if (nextUpdate.data != nullptr) { + HcfFree(nextUpdate.data); + } + (void)x509CrlPem->base.getType(&(x509CrlPem->base)); + HcfX509Certificate *x509Cert = nullptr; + HcfEncodingBlob inStreamCert = { 0 }; + inStreamCert.data = reinterpret_cast(g_testCert); + inStreamCert.encodingFormat = HCF_FORMAT_PEM; + inStreamCert.len = strlen(g_testCert) + 1; + HcfResult result = HcfX509CertificateCreate(&inStreamCert, &x509Cert); + if (result != HCF_SUCCESS) { + return; + } + HcfX509CrlEntry *crlEntry = nullptr; + x509CrlPem->getRevokedCertWithCert(x509CrlPem, x509Cert, &crlEntry); + if (crlEntry != nullptr) { + HcfObjDestroy(crlEntry); + } + (void)x509CrlPem->base.isRevoked(&(x509CrlPem->base), &(x509Cert->base)); + HcfObjDestroy(x509Cert); + } + + static void TestX509CrlEntry(HcfX509Crl *x509CrlDer, const uint8_t *data, size_t size) + { + long serialNumber = 1000; + HcfX509CrlEntry *entry = nullptr; + x509CrlDer->getRevokedCert(x509CrlDer, serialNumber, &entry); + if (entry != nullptr) { + HcfEncodingBlob entryEncoded = { 0 }; + entry->getEncoded(entry, &entryEncoded); + if (entryEncoded.data != nullptr) { + HcfFree(entryEncoded.data); + } + HcfBlob certIssuer = { 0 }; + entry->getCertIssuer(entry, &certIssuer); + if (certIssuer.data != nullptr) { + HcfFree(certIssuer.data); + } + HcfBlob revocationDate = { 0 }; + entry->getRevocationDate(entry, &revocationDate); + if (revocationDate.data != nullptr) { + HcfFree(revocationDate.data); + } + HcfBlob snBlob = { 0 }; + entry->getSerialNumber(entry, &snBlob); + if (snBlob.data != nullptr) { + HcfFree(snBlob.data); + } + HcfObjDestroy(entry); + } + if (size >= sizeof(long)) { + entry = nullptr; + const long *serialNumberPtr = reinterpret_cast(data); + x509CrlDer->getRevokedCert(x509CrlDer, *serialNumberPtr, &entry); + if (entry != nullptr) { + HcfObjDestroy(entry); + } + } + } + + static void TestX509CrlDer(HcfX509Crl *x509CrlDer) + { + HcfArray entrys = { 0 }; + x509CrlDer->getRevokedCerts(x509CrlDer, &entrys); + if (entrys.data != nullptr) { + HcfX509CrlEntry *crlEntry = reinterpret_cast(entrys.data[0].data); + HcfObjDestroy(crlEntry); + } + + HcfBlob signature = { 0 }; + x509CrlDer->getSignature(x509CrlDer, &signature); + if (signature.data != nullptr) { + HcfFree(signature.data); + } + HcfBlob signatureAlgName = { 0 }; + x509CrlDer->getSignatureAlgName(x509CrlDer, &signatureAlgName); + if (signatureAlgName.data != nullptr) { + HcfFree(signatureAlgName.data); + } + HcfBlob signatureAlgOid = { 0 }; + x509CrlDer->getSignatureAlgOid(x509CrlDer, &signatureAlgOid); + if (signatureAlgOid.data != nullptr) { + HcfFree(signatureAlgOid.data); + } + HcfBlob signatureAlgParams = { 0 }; + x509CrlDer->getSignatureAlgParams(x509CrlDer, &signatureAlgParams); + if (signatureAlgParams.data != nullptr) { + HcfFree(signatureAlgParams.data); + } + HcfBlob tbsInfo = { 0 }; + x509CrlDer->getTbsInfo(x509CrlDer, &tbsInfo); + if (tbsInfo.data != nullptr) { + HcfFree(tbsInfo.data); + } + (void)x509CrlDer->getVersion(x509CrlDer); + (void)x509CrlDer->verify(x509CrlDer, g_keyPair->pubKey); + } + + bool FuzzDoX509CrlTest(const uint8_t* data, size_t size) + { + if ((data == nullptr) || (size < sizeof(long))) { + return false; + } + HcfX509Crl *x509CrlDer = nullptr; + HcfEncodingBlob crlDerInStream = { 0 }; + unsigned char *crlStream = GetCrlStream(); + crlDerInStream.data = reinterpret_cast(crlStream); + crlDerInStream.encodingFormat = HCF_FORMAT_DER; + crlDerInStream.len = TEST_CRL_LEN; + HcfResult result = HcfX509CrlCreate(&crlDerInStream, &x509CrlDer); + HcfFree(crlStream); + if (result != HCF_SUCCESS) { + FreeCrlData(); + return false; + } + HcfEncodingBlob crlPemInStream = { 0 }; + crlPemInStream.data = reinterpret_cast(g_testCrl); + crlPemInStream.encodingFormat = HCF_FORMAT_PEM; + crlPemInStream.len = strlen(g_testCrl) + 1; + HcfX509Crl *x509CrlPem = nullptr; + result = HcfX509CrlCreate(&crlPemInStream, &x509CrlPem); + if (result != HCF_SUCCESS) { + FreeCrlData(); + HcfObjDestroy(x509CrlDer); + return false; + } + TestX509CrlPem(x509CrlPem); + HcfObjDestroy(x509CrlPem); + + TestX509CrlEntry(x509CrlDer, data, size); + TestX509CrlDer(x509CrlDer); + FreeCrlData(); + HcfObjDestroy(x509CrlDer); + + HcfX509Crl *x509Crl = nullptr; + HcfEncodingBlob crlInStream = { 0 }; + crlInStream.data = const_cast(data); + crlInStream.encodingFormat = HCF_FORMAT_PEM; + crlInStream.len = size; + result = HcfX509CrlCreate(&crlInStream, &x509Crl); + if (result == HCF_SUCCESS) { + HcfObjDestroy(x509Crl); + } + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::FuzzDoX509CrlTest(data, size); + return 0; +} diff --git a/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.h b/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..c22c89539a497da25e5e61358b70fef8574c03c5 --- /dev/null +++ b/test/fuzztest/certificate/x509crl_fuzzer/x509crl_fuzzer.h @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2022 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 X509_CRL_FUZZER_H +#define X509_CRL_FUZZER_H + +#define FUZZ_PROJECT_NAME "x509crl_fuzzer" +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..b72ab87775bc509f2891d31be09ff75fec0afb77 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfCipherCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfciphercreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfCipherCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..addfee153ab533e29a2726192f76a5f7de50b52d --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2022 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 "hcfciphercreate_fuzzer.h" + +#include +#include +#include +#include "securec.h" + +#include "asy_key_generator.h" +#include "blob.h" +#include "cipher.h" +#include "mac.h" +#include "result.h" +#include "sym_key_generator.h" + +namespace OHOS { + static bool g_testFlag = true; + + static int32_t AesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, + uint8_t *cipherText, int *cipherTextLen) + { + uint8_t plainText[] = "this is test!"; + HcfBlob input = {.data = reinterpret_cast(plainText), .len = 13}; + HcfBlob output = {}; + int32_t maxLen = *cipherTextLen; + int32_t ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), params); + if (ret != 0) { + return ret; + } + + ret = cipher->update(cipher, &input, &output); + if (ret != 0) { + return ret; + } + *cipherTextLen = output.len; + if (output.len > 0 && output.data != nullptr) { + (void)memcpy_s(cipherText, maxLen, output.data, output.len); + } + if (output.data != nullptr) { + HcfBlobDataClearAndFree(&output); + output.data = nullptr; + } + ret = cipher->doFinal(cipher, nullptr, &output); + if (ret != 0) { + return ret; + } + if (output.len > 0 && output.data != nullptr) { + (void)memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len); + } + *cipherTextLen += output.len; + if (output.data != nullptr) { + HcfBlobDataClearAndFree(&output); + output.data = nullptr; + } + return 0; + } + + static int32_t AesDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, + uint8_t *cipherText, int cipherTextLen) + { + uint8_t plainText[] = "this is test!"; + HcfBlob input = {.data = cipherText, .len = cipherTextLen}; + HcfBlob output = {}; + int32_t maxLen = cipherTextLen; + int32_t ret = cipher->init(cipher, DECRYPT_MODE, &(key->key), params); + if (ret != 0) { + return ret; + } + + ret = cipher->update(cipher, &input, &output); + if (ret != 0) { + return ret; + } + if (output.len > 0 && output.data != nullptr) { + (void)memcpy_s(cipherText, maxLen, output.data, output.len); + } + cipherTextLen = output.len; + if (output.data != nullptr) { + HcfBlobDataClearAndFree(&output); + output.data = nullptr; + output.len = 0; + } + ret = cipher->doFinal(cipher, nullptr, &output); + if (ret != 0) { + return ret; + } + if (output.len > 0 && output.data != nullptr) { + (void)memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len); + } + cipherTextLen += output.len; + if (output.data != nullptr) { + HcfBlobDataClearAndFree(&output); + output.data = nullptr; + output.len = 0; + } + ret = memcmp(cipherText, plainText, cipherTextLen); + ret = ret || (cipherTextLen == sizeof(plainText) - 1) ? 0 : 1; + return ret; + } + + static void TestAesCipher(void) + { + int ret = 0; + uint8_t cipherText[128] = {0}; + int cipherTextLen = 128; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != HCF_SUCCESS) { + return; + } + ret = generator->generateSymKey(generator, &key); + if (ret != HCF_SUCCESS) { + HcfObjDestroy(generator); + return; + } + ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); + if (ret != HCF_SUCCESS) { + HcfObjDestroy(generator); + HcfObjDestroy(key); + return; + } + + (void)AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + (void)AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + HcfObjDestroy(generator); + HcfObjDestroy(key); + HcfObjDestroy(cipher); + } + + static void TestRsaCipher(void) + { + HcfResult res = HCF_SUCCESS; + uint8_t plan[] = "this is rsa cipher test!\0"; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + if (res != HCF_SUCCESS) { + return; + } + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(generator); + return; + } + + HcfBlob input = { .data = plan, .len = strlen(reinterpret_cast(plan)) }; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + if (res != HCF_SUCCESS) { + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + return; + } + + (void)cipher->init(cipher, ENCRYPT_MODE, reinterpret_cast(keyPair->pubKey), nullptr); + (void)cipher->doFinal(cipher, &input, &encoutput); + HcfObjDestroy(cipher); + + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + if (res != HCF_SUCCESS) { + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + return; + } + (void)cipher->init(cipher, DECRYPT_MODE, reinterpret_cast(keyPair->priKey), nullptr); + (void)cipher->doFinal(cipher, &encoutput, &decoutput); + HcfBlobDataClearAndFree(&encoutput); + HcfBlobDataClearAndFree(&decoutput); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(cipher); + } + + bool HcfCipherCreateFuzzTest(const uint8_t* data, size_t size) + { + if (g_testFlag) { + TestRsaCipher(); + TestAesCipher(); + g_testFlag = false; + } + HcfCipher *cipher = nullptr; + std::string algoName(reinterpret_cast(data), size); + HcfResult res = HcfCipherCreate(algoName.c_str(), &cipher); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(cipher); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfCipherCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..b61439400e6ca855364b140565014adae0f9eb73 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_CIPHER_CREATE_FUZZER_H +#define HCF_CIPHER_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfciphercreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..6c524bb310fcfbd4939098ee39dbc76a2c4885e1 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfKeyAgreementCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfkeyagreementcreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfKeyAgreementCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..09dd8ff2b5a79553174624edd6c6c94f8428f0b6 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2022 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 "hcfkeyagreementcreate_fuzzer.h" + +#include +#include +#include + +#include "blob.h" +#include "key_agreement.h" +#include "result.h" + +namespace OHOS { + bool HcfKeyAgreementCreateFuzzTest(const uint8_t* data, size_t size) + { + HcfKeyAgreement *keyAgreement = nullptr; + std::string algoName(reinterpret_cast(data), size); + int32_t res = HcfKeyAgreementCreate(algoName.c_str(), &keyAgreement); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(keyAgreement); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfKeyAgreementCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..f0a5a7a2c8eba276ae9e4c799cc7521b6a4ff220 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_KEY_AGREEMENT_CREATE_FUZZER_H +#define HCF_KEY_AGREEMENT_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfkeyagreementcreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..7355009268e234723b4e8218b24c6ec6dc8dec21 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfMacCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfmaccreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfMacCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..06e7a02a212f1fdd4b31151bc9b742bb8f668fa6 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2022 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 "hcfmaccreate_fuzzer.h" + +#include +#include +#include + +#include "blob.h" +#include "mac.h" +#include "result.h" +#include "sym_key_generator.h" + +namespace OHOS { + static const int KEY_LEN = 16; + static const int TEST_DATA_LEN = 12; + + static void TestMac(void) + { + HcfMac *macObj = nullptr; + HcfResult res = HcfMacCreate("SHA1", &macObj); + if (res != HCF_SUCCESS) { + return; + } + HcfSymKeyGenerator *generator = nullptr; + (void)HcfSymKeyGeneratorCreate("AES128", &generator); + char testKey[] = "abcdefghijklmnop"; + uint32_t testKeyLen = KEY_LEN; + HcfSymKey *key = nullptr; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; + generator->convertSymKey(generator, &keyMaterialBlob, &key); + + char testData[] = "My test data"; + uint32_t testDataLen = TEST_DATA_LEN; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; + (void)macObj->init(macObj, key); + (void)macObj->update(macObj, &inBlob); + HcfBlob outBlob = { 0 }; + (void)macObj->doFinal(macObj, &outBlob); + (void)macObj->getAlgoName(macObj); + (void)macObj->getMacLength(macObj); + HcfBlobDataClearAndFree(&outBlob); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); + } + + bool HcfMacCreateFuzzTest(const uint8_t* data, size_t size) + { + TestMac(); + HcfMac *macObj = nullptr; + std::string alg(reinterpret_cast(data), size); + HcfResult res = HcfMacCreate(alg.c_str(), &macObj); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(macObj); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfMacCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..d058f906e0b725256521a21d9ab98fe2e2af7dcc --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/hcfmaccreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_MAC_CREATE_FUZZER_H +#define HCF_MAC_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfmaccreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmaccreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..0544d2d15985225104ac076295386bad762ee575 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfMdCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfmdcreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfMdCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..0cacfaf1221f5cadc4a48e3e31ef42fee7dc1a7b --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2022 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 "hcfmdcreate_fuzzer.h" + +#include +#include +#include + +#include "blob.h" +#include "md.h" +#include "result.h" + +namespace OHOS { + static const int TEST_DATA_LEN = 12; + + static void TestMd(void) + { + HcfMd *mdObj = nullptr; + HcfResult res = HcfMdCreate("SHA1", &mdObj); + if (res != HCF_SUCCESS) { + return; + } + char testData[] = "My test data"; + uint32_t testDataLen = TEST_DATA_LEN; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; + (void)mdObj->update(mdObj, &inBlob); + HcfBlob outBlob = { 0 }; + (void)mdObj->doFinal(mdObj, &outBlob); + (void)mdObj->getAlgoName(mdObj); + (void)mdObj->getMdLength(mdObj); + HcfBlobDataClearAndFree(&outBlob); + HcfObjDestroy(mdObj); + } + + bool HcMdCreateFuzzTest(const uint8_t* data, size_t size) + { + TestMd(); + HcfMd *mdObj = nullptr; + std::string alg(reinterpret_cast(data), size); + HcfResult res = HcfMdCreate(alg.c_str(), &mdObj); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(mdObj); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcMdCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..83ff24971da4130209e1d06f5c88dce97d9a2c14 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/hcfmdcreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_MD_CREATE_FUZZER_H +#define HCF_MD_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfmdcreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfmdcreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..419f7e3b88811f29a15d752efc783c4140b6f379 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfSignCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfsigncreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfSignCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..19cd821d0d33fd6fec3cc8ac79f71fde8b1a8398 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2022 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 "hcfsigncreate_fuzzer.h" + +#include +#include +#include + +#include "asy_key_generator.h" +#include "blob.h" +#include "result.h" +#include "signature.h" + +namespace OHOS { + static char g_mockMessage[] = "hello world"; + const int INPUT_MSG_LEN = 12; + + static void TestSign(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("ECC384", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *ecc384KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &ecc384KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC384|SHA384", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(ecc384KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, ecc384KeyPair->priKey); + (void)sign->update(sign, &mockInput); + HcfObjDestroy(ecc384KeyPair); + HcfObjDestroy(sign); + } + + bool HcfSignCreateFuzzTest(const uint8_t* data, size_t size) + { + TestSign(); + HcfSign *sign = nullptr; + std::string algoName(reinterpret_cast(data), size); + HcfResult res = HcfSignCreate(algoName.c_str(), &sign); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(sign); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfSignCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..41b045364baf802d84e2d85ccc34f03cf56db167 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_SIGN_CREATE_FUZZER_H +#define HCF_SIGN_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfsigncreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/BUILD.gn b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..66c370a9cad200ddd64f97afc3c87907282a0bd6 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/crypto_operation" + +##############################fuzztest########################################## +ohos_fuzztest("HcfVerifyCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfverifycreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfVerifyCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/corpus/init b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..7fbe43c2feac502ee35560870abc11c9e1b068de --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2022 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 "hcfverifycreate_fuzzer.h" + +#include +#include +#include + +#include "asy_key_generator.h" +#include "blob.h" +#include "result.h" +#include "signature.h" + +namespace OHOS { + static char g_mockMessage[] = "hello world"; + const int INPUT_MSG_LEN = 12; + + static void TestVerify(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *ecc224KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &ecc224KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC224|SHA384", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(ecc224KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, ecc224KeyPair->priKey); + (void)sign->update(sign, &mockInput); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC224|SHA384", &verify); + if (res != HCF_SUCCESS) { + HcfObjDestroy(ecc224KeyPair); + HcfObjDestroy(sign); + return; + } + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + (void)sign->sign(sign, nullptr, &out); + (void)verify->init(verify, nullptr, ecc224KeyPair->pubKey); + (void)verify->update(verify, &mockInput); + (void)verify->verify(verify, nullptr, &out); + HcfObjDestroy(ecc224KeyPair); + HcfObjDestroy(sign); + HcfBlobDataFree(&out); + HcfObjDestroy(verify); + } + + bool HcfVerifyCreateFuzzTest(const uint8_t* data, size_t size) + { + TestVerify(); + HcfVerify *verify = nullptr; + std::string algoName(reinterpret_cast(data), size); + HcfResult res = HcfVerifyCreate(algoName.c_str(), &verify); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(verify); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfVerifyCreateFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.h b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..3829139a25f92923f71f6685a553f10582b2b5f9 --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_VERIFY_CREATE_FUZZER_H +#define HCF_VERIFY_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfverifycreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/project.xml b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/BUILD.gn b/test/fuzztest/key/asykeygenerator_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..7bf850e2b6e795953681ca4763355e655828ce23 --- /dev/null +++ b/test/fuzztest/key/asykeygenerator_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/key" + +##############################fuzztest########################################## +ohos_fuzztest("AsyKeyGeneratorFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/key/asykeygenerator_fuzzer" + include_dirs = framework_inc_path + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "asykeygenerator_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":AsyKeyGeneratorFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..725ca7508f3e7e731817ae4cd99bf2f29dc0b3e8 --- /dev/null +++ b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2022 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 "asykeygenerator_fuzzer.h" + +#include +#include +#include + +#include "asy_key_generator.h" +#include "blob.h" +#include "result.h" + +namespace OHOS { + static bool g_testFlag = true; + static const int ECC224_PUB_KEY_LEN = 80; + static const int ECC224_PRI_KEY_LEN = 44; + static uint8_t g_mockEcc224PubKey[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, + 61, 2, 1, 6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207, + 141, 146, 235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181, + 172, 192, 2, 99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 }; + + static uint8_t g_mockEcc224PriKey[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, + 147, 222, 43, 252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198, + 19, 160, 7, 6, 5, 43, 129, 4, 0, 33 }; + + static void TestEccKey(void) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + return; + } + (void)generator->getAlgoName(generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(generator); + return; + } + HcfKeyPair *convertKeyPair = nullptr; + static HcfBlob mockEcc224PubKeyBlob = { + .data = g_mockEcc224PubKey, + .len = ECC224_PUB_KEY_LEN + }; + + static HcfBlob mockEcc224PriKeyBlob = { + .data = g_mockEcc224PriKey, + .len = ECC224_PRI_KEY_LEN + }; + (void)generator->convertKey(generator, nullptr, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &convertKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(convertKeyPair); + } + + static void TestRsaKey(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + if (res != HCF_SUCCESS) { + return; + } + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(generator); + return; + } + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; + (void)keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); + (void)keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + + HcfKeyPair *dupKeyPair = nullptr; + (void)generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfPubKey *pubKey = dupKeyPair->pubKey; + (void)pubKey->base.getAlgorithm(&(pubKey->base)); + (void)pubKey->base.getFormat(&(pubKey->base)); + (void)pubKey->base.base.getClass(); + + HcfBlobDataFree(&pubKeyBlob); + HcfBlobDataFree(&priKeyBlob); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); + } + + bool AsyKeyGeneratorFuzzTest(const uint8_t* data, size_t size) + { + if (g_testFlag) { + TestEccKey(); + TestRsaKey(); + g_testFlag = false; + } + HcfAsyKeyGenerator *generator = nullptr; + std::string algoName(reinterpret_cast(data), size); + HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + if (res != HCF_SUCCESS) { + return false; + } + HcfObjDestroy(generator); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::AsyKeyGeneratorFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.h b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..068360a02ce02d2922a267c6fa5f15249e9ec373 --- /dev/null +++ b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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 ASY_KEY_GENERATOR_FUZZER_H +#define ASY_KEY_GENERATOR_FUZZER_H + +#define FUZZ_PROJECT_NAME "asykeygenerator_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init b/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/project.xml b/test/fuzztest/key/asykeygenerator_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..85e7ef2c1cc6471e288306f6e3dcea5287a78b0e --- /dev/null +++ b/test/fuzztest/key/asykeygenerator_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/key/symkeygenerator_fuzzer/BUILD.gn b/test/fuzztest/key/symkeygenerator_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..698bf9918233bce145d38866274e2ce4c82f6f84 --- /dev/null +++ b/test/fuzztest/key/symkeygenerator_fuzzer/BUILD.gn @@ -0,0 +1,66 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") +import("//base/security/crypto_framework/plugin/plugin.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/key" + +##############################fuzztest########################################## +ohos_fuzztest("SymKeyGeneratorFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "//base/security/crypto_framework/test/fuzztest/key/symkeygenerator_fuzzer" + include_dirs = [ "./include" ] + include_dirs += [ + "//commonlibrary/c_utils/base/include", + "//third_party/openssl/include/", + ] + include_dirs += framework_inc_path + plugin_inc_path + sources = [ "symkeygenerator_fuzzer.cpp" ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-DHILOG_ENABLE", + ] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//third_party/openssl:libcrypto_shared", + ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":SymKeyGeneratorFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/key/symkeygenerator_fuzzer/corpus/init b/test/fuzztest/key/symkeygenerator_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/key/symkeygenerator_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/key/symkeygenerator_fuzzer/project.xml b/test/fuzztest/key/symkeygenerator_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/key/symkeygenerator_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.cpp b/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ca72087ce6171777fc264fdef17302c8f5ce85d6 --- /dev/null +++ b/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.cpp @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2022 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 "symkeygenerator_fuzzer.h" + +#include +#include +#include +#include "securec.h" +#include "result.h" +#include "memory.h" +#include "sym_key_generator.h" + +namespace OHOS { +bool SymKeyGeneratorFuzzTest(const uint8_t* data, size_t size) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + std::string algoName(reinterpret_cast(data), size); + ret = HcfSymKeyGeneratorCreate(algoName.c_str(), &generator); + if (ret != HCF_SUCCESS) { + return false; + } + + ret = generator->generateSymKey(generator, &key); + if (ret != HCF_SUCCESS) { + HcfObjDestroy(generator); + return false; + } + key->clearMem(key); + HcfObjDestroy(generator); + HcfObjDestroy(key); + return true; +} +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::SymKeyGeneratorFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.h b/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..ee972be32e7b6fdaaf36269810788a1e3e349e5e --- /dev/null +++ b/test/fuzztest/key/symkeygenerator_fuzzer/symkeygenerator_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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 SYM_KEY_GENERATOR_FUZZER_H +#define SYM_KEY_GENERATOR_FUZZER_H + +#define FUZZ_PROJECT_NAME "symkeygenerator_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/rand/hcfrandcreate_fuzzer/BUILD.gn b/test/fuzztest/rand/hcfrandcreate_fuzzer/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..597ca5e653a81536c9bf48ea27b15db9f663943f --- /dev/null +++ b/test/fuzztest/rand/hcfrandcreate_fuzzer/BUILD.gn @@ -0,0 +1,53 @@ +# Copyright (c) 2022 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/frameworks/frameworks.gni") + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "crypto_framework/rand" + +##############################fuzztest########################################## +ohos_fuzztest("HcfRandCreateFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = + "//base/security/crypto_framework/test/fuzztest/rand/hcfrandcreate_fuzzer" + include_dirs = framework_inc_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "hcfrandcreate_fuzzer.cpp" ] + deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hiviewdfx_hilog_native:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":HcfRandCreateFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/rand/hcfrandcreate_fuzzer/corpus/init b/test/fuzztest/rand/hcfrandcreate_fuzzer/corpus/init new file mode 100755 index 0000000000000000000000000000000000000000..c49c21aa8683c4d54af710059267afe15db14f96 --- /dev/null +++ b/test/fuzztest/rand/hcfrandcreate_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2022 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.cpp b/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.cpp new file mode 100755 index 0000000000000000000000000000000000000000..e4e7780b0c766323d2263deb570c3b4cb238a2a2 --- /dev/null +++ b/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2022 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 "hcfrandcreate_fuzzer.h" + +#include +#include + +#include "blob.h" +#include "rand.h" +#include "result.h" + +namespace OHOS { + bool HcfRandCreateFuzzTest(const uint8_t* data, size_t size) + { + HcfRand *randObj = nullptr; + HcfResult res = HcfRandCreate(&randObj); + if (res != HCF_SUCCESS) { + return false; + } + struct HcfBlob randomBlob = { 0 }; + (void)randObj->generateRandom(randObj, size, &randomBlob); + struct HcfBlob seedBlob = { 0 }; + (void)randObj->setSeed(randObj, &seedBlob); + HcfBlobDataFree(&randomBlob); + HcfBlobDataFree(&seedBlob); + HcfObjDestroy(randObj); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::HcfRandCreateFuzzTest(data, size); + return 0; +} + diff --git a/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.h b/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.h new file mode 100755 index 0000000000000000000000000000000000000000..642681310f38e0035b5465b4d15a326ffef578d0 --- /dev/null +++ b/test/fuzztest/rand/hcfrandcreate_fuzzer/hcfrandcreate_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 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_RAND_CREATE_FUZZER_H +#define HCF_RAND_CREATE_FUZZER_H + +#define FUZZ_PROJECT_NAME "hcfrandcreate_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/rand/hcfrandcreate_fuzzer/project.xml b/test/fuzztest/rand/hcfrandcreate_fuzzer/project.xml new file mode 100755 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/rand/hcfrandcreate_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 00aafbb599cc3e5721eeb2105be68735e4b387a8..83dd25cc02b374abbe77de147453016bb171f326 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -47,14 +47,32 @@ ohos_unittest("crypto_framework_test") { "src/crypto_x509_crl_test.cpp", ] + sources += framework_files + plugin_files + sources += [ + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/src/certificate_openssl_common.c", + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/src/x509_cert_chain_validator_openssl.c", + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/src/x509_certificate_openssl.c", + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/src/x509_crl_entry_openssl.c", + "//base/security/crypto_framework/plugin/openssl_plugin/certificate/src/x509_crl_openssl.c", + ] + sources -= [ "//base/security/crypto_framework/plugin/openssl_plugin/common/src/openssl_adapter.c" ] + sources += [ + "//base/security/crypto_framework/common/src/blob.c", + "//base/security/crypto_framework/common/src/hcf_parcel.c", + "//base/security/crypto_framework/common/src/hcf_string.c", + "//base/security/crypto_framework/common/src/log.c", + "//base/security/crypto_framework/common/src/object_base.c", + "//base/security/crypto_framework/common/src/params_parser.c", + "//base/security/crypto_framework/common/src/utils.c", + "src/memory_mock.c", + "src/openssl_adapter_mock.c", + ] cflags = [ "-DHILOG_ENABLE" ] if (target_cpu == "arm") { cflags += [ "-DBINDER_IPC_32BIT" ] } deps = [ - "//base/security/crypto_framework:crypto_framework_lib", - "//base/security/crypto_framework:crypto_openssl_plugin_lib", "//third_party/bounds_checking_function:libsec_shared", "//third_party/openssl:libcrypto_shared", ] diff --git a/test/unittest/include/memory_mock.h b/test/unittest/include/memory_mock.h new file mode 100755 index 0000000000000000000000000000000000000000..0647a53453c3b5271bb335ce6a2fcef3db260db5 --- /dev/null +++ b/test/unittest/include/memory_mock.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2022 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 MEMORY_MOCK_H +#define MEMORY_MOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void SetMockFlag(bool flag); +void StartRecordMallocNum(void); +void EndRecordMallocNum(void); +uint32_t GetMallocNum(void); +void ResetRecordMallocNum(void); +void SetMockMallocIndex(uint32_t index); + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/test/unittest/include/openssl_adapter_mock.h b/test/unittest/include/openssl_adapter_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..2d37586beaac688905df60d485cec9485c959848 --- /dev/null +++ b/test/unittest/include/openssl_adapter_mock.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 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 OPENSSL_ADAPTER_MOCK_H +#define OPENSSL_ADAPTER_MOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void StartRecordOpensslCallNum(void); +uint32_t GetOpensslCallNum(void); +void ResetOpensslCallNum(void); +void SetOpensslCallMockIndex(uint32_t index); +void EndRecordOpensslCallNum(void); + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/test/unittest/src/crypto_3des_cipher_test.cpp b/test/unittest/src/crypto_3des_cipher_test.cpp index 3bd0b5ca67cd96c79f314cc13cd65c1e6187871d..510cdaa2ab81153ed1c09ab382703d38a332d3b8 100644 --- a/test/unittest/src/crypto_3des_cipher_test.cpp +++ b/test/unittest/src/crypto_3des_cipher_test.cpp @@ -23,12 +23,16 @@ #include "detailed_iv_params.h" #include "detailed_gcm_params.h" #include "detailed_ccm_params.h" - +#include "aes_openssl.h" using namespace std; using namespace testing::ext; namespace { +constexpr int32_t CIPHER_TEXT_LEN = 128; +constexpr int32_t DES_IV_LEN = 8; +constexpr int32_t PLAINTEXT_LEN = 13; + class Crypto3DesCipherTest : public testing::Test { public: static void SetUpTestCase(); @@ -48,6 +52,24 @@ void Crypto3DesCipherTest::TearDown() // add destroy here, this will be called w { } +static int32_t GenerateDesSymKey(HcfSymKey **key) +{ + HcfSymKeyGenerator *generator = nullptr; + + int32_t ret = HcfSymKeyGeneratorCreate("3DES192", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!"); + return ret; + } + + ret = generator->generateSymKey(generator, key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + HcfObjDestroy(generator); + return ret; +} + static int32_t DesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, uint8_t *cipherText, int *cipherTextLen) { @@ -67,25 +89,26 @@ static int32_t DesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *para return ret; } *cipherTextLen = output.len; - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + HcfBlobDataFree(&output); } - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - } - ret = cipher->doFinal(cipher, NULL, &output); + + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len); - } - *cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; + if (output.data != nullptr) { + if (memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); } return 0; } @@ -108,33 +131,33 @@ static int32_t DesDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *para LOGE("update failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } cipherTextLen = output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + HcfBlobDataFree(&output); } - ret = cipher->doFinal(cipher, NULL, &output); + + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len); - } - cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + if (output.data != nullptr) { + if (memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + cipherTextLen += output.len; + HcfBlobDataFree(&output); } - ret = memcmp(cipherText, plainText, cipherTextLen); - ret = ret || (sizeof(plainText) - 1 == cipherTextLen) ? 0 : 1; - return ret; + if (cipherTextLen != sizeof(plainText) - 1) { + return -1; + } + return memcmp(cipherText, plainText, cipherTextLen); } static int32_t DesNoUpdateEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, @@ -156,13 +179,13 @@ static int32_t DesNoUpdateEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSp LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } - *cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); } return 0; } @@ -186,19 +209,19 @@ static int32_t DesNoUpdateDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSp LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } - cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + cipherTextLen += output.len; + HcfBlobDataFree(&output); } - ret = memcmp(cipherText, plainText, cipherTextLen); - ret = ret || (sizeof(plainText) - 1 == cipherTextLen) ? 0 : 1; - return ret; + if (cipherTextLen != sizeof(plainText) - 1) { + return -1; + } + return memcmp(cipherText, plainText, cipherTextLen); } HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest001, TestSize.Level0) @@ -207,9 +230,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest001, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -229,22 +252,22 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest001, TestSize.Level0) goto clearup; } - ret = DesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesEncrypt failed! %d", ret); goto clearup; } - ret = DesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesDecrypt failed! %d", ret); goto clearup; } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -254,9 +277,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest002, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -276,13 +299,13 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest002, TestSize.Level0) goto clearup; } - ret = DesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesEncrypt failed! %d", ret); goto clearup; } - ret = DesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesDecrypt failed! %d", ret); goto clearup; @@ -290,9 +313,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest002, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -302,9 +325,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest003, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -324,22 +347,22 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest003, TestSize.Level0) goto clearup; } - ret = DesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesEncrypt failed! %d", ret); goto clearup; } - ret = DesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesDecrypt failed! %d", ret); goto clearup; } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -350,9 +373,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest004, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -389,9 +412,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest004, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -401,9 +424,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest005, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -439,9 +462,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest005, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -451,9 +474,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest006, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -489,9 +512,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest006, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -501,9 +524,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest007, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -541,9 +564,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest007, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -553,9 +576,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest008, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -591,9 +614,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest008, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -603,9 +626,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest009, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -643,9 +666,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest009, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -655,9 +678,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest010, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -694,9 +717,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest010, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -706,9 +729,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest011, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -745,9 +768,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest011, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -757,9 +780,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest012, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -796,9 +819,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest012, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -808,9 +831,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest013, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -830,22 +853,22 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest013, TestSize.Level0) goto clearup; } - ret = DesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateEncrypt failed! %d", ret); goto clearup; } - ret = DesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateDecrypt failed! %d", ret); goto clearup; } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -855,9 +878,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest014, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -877,13 +900,13 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest014, TestSize.Level0) goto clearup; } - ret = DesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateEncrypt failed! %d", ret); goto clearup; } - ret = DesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateDecrypt failed! %d", ret); goto clearup; @@ -891,9 +914,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest014, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -903,9 +926,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest015, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("3DES192", &generator); if (ret != 0) { @@ -925,22 +948,22 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest015, TestSize.Level0) goto clearup; } - ret = DesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateEncrypt failed! %d", ret); goto clearup; } - ret = DesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = DesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("DesNoUpdateDecrypt failed! %d", ret); goto clearup; } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -951,9 +974,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest016, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -990,9 +1013,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest016, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -1002,9 +1025,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest017, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1041,9 +1064,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest017, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1053,9 +1076,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest018, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1092,9 +1115,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest018, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1104,9 +1127,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest019, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1144,9 +1167,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest019, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1156,9 +1179,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest020, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1195,9 +1218,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest020, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1207,9 +1230,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest021, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1247,9 +1270,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest021, TestSize.Level0) clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1259,9 +1282,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest022, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1298,9 +1321,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest022, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1310,9 +1333,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest023, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1349,9 +1372,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest023, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1361,9 +1384,9 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest024, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t iv[8] = {0}; HcfIvParamsSpec ivSpec = {}; ivSpec.iv.data = iv; @@ -1400,9 +1423,396 @@ HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest024, TestSize.Level0) } clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest025, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t iv[DES_IV_LEN] = { 0 }; + HcfIvParamsSpec ivSpec = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = DES_IV_LEN; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|CFB1|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("DesEncrypt failed! %d", ret); + goto clearup; + } + + ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("DesDecrypt failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); EXPECT_EQ(ret, 0); } -} \ No newline at end of file + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest026, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t iv[DES_IV_LEN] = { 0 }; + HcfIvParamsSpec ivSpec = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = DES_IV_LEN; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|CFB8|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("DesEncrypt failed! %d", ret); + goto clearup; + } + + ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("DesDecrypt failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest027, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t iv[DES_IV_LEN] = { 0 }; + HcfIvParamsSpec ivSpec = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = DES_IV_LEN; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("DesEncrypt failed! %d", ret); + goto clearup; + } + + ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("DesDecrypt failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest028, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest029, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = HcfSymKeyGeneratorCreate("3DES192", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!"); + goto clearup; + } + + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(reinterpret_cast(generator), ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest030, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, reinterpret_cast(cipher), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + } + +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest031, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + goto clearup; + } + ret = cipher->update(nullptr, &input, &output); + if (ret != 0) { + LOGE("update failed!"); + } +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest032, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + goto clearup; + } + ret = cipher->update(reinterpret_cast(key), &input, &output); + if (ret != 0) { + LOGE("update failed!"); + } +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest033, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + goto clearup; + } + ret = cipher->doFinal(nullptr, &input, &output); + if (ret != 0) { + LOGE("doFinal failed!"); + } +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest034, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateDesSymKey(&key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto clearup; + } + + ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto clearup; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + goto clearup; + } + ret = cipher->doFinal(reinterpret_cast(key), &input, &output); + if (ret != 0) { + LOGE("doFinal failed!"); + } +clearup: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest035, TestSize.Level0) +{ + int ret = HcfCipherDesGeneratorSpiCreate(nullptr, nullptr); + if (ret != 0) { + LOGE("HcfCipherDesGeneratorSpiCreate failed!"); + } + EXPECT_NE(ret, 0); +} +} diff --git a/test/unittest/src/crypto_aes_cipher_test.cpp b/test/unittest/src/crypto_aes_cipher_test.cpp index fabfe24602237fe358e0332664cce2a9fabd1f24..e7bf4ec85f5c45bdb5c046e8ba0b9c48794e2af3 100644 --- a/test/unittest/src/crypto_aes_cipher_test.cpp +++ b/test/unittest/src/crypto_aes_cipher_test.cpp @@ -18,14 +18,16 @@ #include #include "securec.h" -#include "sym_key_generator.h" +#include "aes_openssl.h" +#include "blob.h" #include "cipher.h" -#include "log.h" -#include "memory.h" #include "detailed_iv_params.h" #include "detailed_gcm_params.h" #include "detailed_ccm_params.h" - +#include "log.h" +#include "memory.h" +#include "sym_common_defines.h" +#include "sym_key_generator.h" using namespace std; using namespace testing::ext; @@ -34,6 +36,17 @@ namespace { const int32_t FILE_BLOCK_SIZE = 1024; const int32_t RAND_MAX_NUM = 100; const bool IS_DEBUG = false; +constexpr int32_t CIPHER_TEXT_LEN = 128; +constexpr int32_t KEY_MATERIAL_LEN = 16; +constexpr int32_t AES_IV_LEN = 16; // iv for CBC|CTR|OFB|CFB mode +constexpr int32_t GCM_IV_LEN = 12; // GCM +constexpr int32_t GCM_AAD_LEN = 8; +constexpr int32_t GCM_TAG_LEN = 16; +constexpr int32_t CCM_IV_LEN = 7; // CCM +constexpr int32_t CCM_AAD_LEN = 8; +constexpr int32_t CCM_TAG_LEN = 12; +constexpr int32_t PLAINTEXT_LEN = 13; +constexpr int32_t AES_KEY_SIZE = 128; class CryptoAesCipherTest : public testing::Test { public: @@ -69,7 +82,7 @@ static void PrintfHex(const char *tag, uint8_t *in, int inLen) static int32_t GenerateSymKey(const char *algoName, HcfSymKey **key) { - HcfSymKeyGenerator *generator = NULL; + HcfSymKeyGenerator *generator = nullptr; int32_t ret = HcfSymKeyGeneratorCreate(algoName, &generator); if (ret != 0) { @@ -81,13 +94,13 @@ static int32_t GenerateSymKey(const char *algoName, HcfSymKey **key) if (ret != 0) { LOGE("generateSymKey failed!"); } - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)generator); return ret; } static int32_t ConvertSymKey(const char *algoName, HcfSymKey **key) { - HcfSymKeyGenerator *generator = NULL; + HcfSymKeyGenerator *generator = nullptr; uint8_t keyMaterial[] = { 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c @@ -105,7 +118,7 @@ static int32_t ConvertSymKey(const char *algoName, HcfSymKey **key) LOGE("generateSymKey failed!"); } PrintfHex("keybinary", keyTmpBlob.data, keyTmpBlob.len); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); + HcfObjDestroy((HcfObjectBase *)generator); return ret; } @@ -159,10 +172,10 @@ static int32_t CompareFileContent() infile2.read(reinterpret_cast(buffer2), FILE_BLOCK_SIZE); ret = memcmp(buffer1, buffer2, FILE_BLOCK_SIZE); if (ret != 0) { - goto clearup; + goto CLEAR_UP; } } -clearup: +CLEAR_UP: infile1.close(); infile2.close(); return ret; @@ -185,37 +198,37 @@ static int32_t AesMultiBlockEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParams int32_t ret = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)key, params); if (ret != 0) { LOGE("init failed! %d", ret); - goto clearup; + goto CLEAR_UP; } for (uint32_t i = 0; i < count; i++) { infile.read(reinterpret_cast(buffer), FILE_BLOCK_SIZE); ret = cipher->update(cipher, &input, &output); if (ret != 0) { LOGE("update failed!"); - goto clearup; + goto CLEAR_UP; } if (output.data != nullptr && output.len > 0) { outfile.write(reinterpret_cast(output.data), output.len); } - if (output.data != NULL) { + if (output.data != nullptr) { HcfFree(output.data); - output.data = NULL; + output.data = nullptr; } } - ret = cipher->doFinal(cipher, NULL, &output); + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); - goto clearup; + goto CLEAR_UP; } if (output.data != nullptr && output.len > 0) { outfile.write((const char *)output.data, output.len); } - if (output.data != NULL) { + if (output.data != nullptr) { HcfFree(output.data); - output.data = NULL; + output.data = nullptr; } -clearup: +CLEAR_UP: outfile.close(); infile.close(); @@ -239,43 +252,87 @@ static int32_t AesMultiBlockDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParams int32_t ret = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)key, params); if (ret != 0) { LOGE("init failed! %d", ret); - goto clearup; + goto CLEAR_UP; } for (uint32_t i = 0; i < count; i++) { infile.read(reinterpret_cast(buffer), FILE_BLOCK_SIZE); ret = cipher->update(cipher, &input, &output); if (ret != 0) { LOGE("update failed!"); - goto clearup; + goto CLEAR_UP; } if (output.data != nullptr && output.len > 0) { outfile.write(reinterpret_cast(output.data), output.len); } - if (output.data != NULL) { + if (output.data != nullptr) { HcfFree(output.data); - output.data = NULL; + output.data = nullptr; } } - ret = cipher->doFinal(cipher, NULL, &output); + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); - goto clearup; + goto CLEAR_UP; } if (output.data != nullptr && output.len > 0) { outfile.write((const char *)output.data, output.len); } - if (output.data != NULL) { + if (output.data != nullptr) { HcfFree(output.data); - output.data = NULL; + output.data = nullptr; } -clearup: +CLEAR_UP: outfile.close(); infile.close(); return ret; } +// use ECB, test abnormal input +static int32_t AesEncryptWithInput(HcfCipher *cipher, HcfSymKey *key, HcfBlob *input, + uint8_t *cipherText, int *cipherTextLen) +{ + HcfBlob output = { .data = nullptr, .len = 0 }; + int32_t maxLen = *cipherTextLen; + int32_t ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + return ret; + } + + ret = cipher->update(cipher, input, &output); + if (ret != 0) { + LOGE("update failed!"); + return ret; + } + *cipherTextLen = output.len; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + HcfBlobDataFree(&output); + } + + ret = cipher->doFinal(cipher, nullptr, &output); + if (ret != 0) { + LOGE("doFinal failed!"); + return ret; + } + if (output.data != nullptr) { + if (memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); + } + + PrintfHex("ciphertext", cipherText, *cipherTextLen); + return 0; +} + static int32_t AesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, uint8_t *cipherText, int *cipherTextLen) { @@ -295,26 +352,28 @@ static int32_t AesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *para return ret; } *cipherTextLen = output.len; - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + HcfBlobDataFree(&output); } - ret = cipher->doFinal(cipher, NULL, &output); + + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len); - } - *cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; + if (output.data != nullptr) { + if (memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); } + PrintfHex("ciphertext", cipherText, *cipherTextLen); return 0; } @@ -337,32 +396,89 @@ static int32_t AesDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *para LOGE("update failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } cipherTextLen = output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + HcfBlobDataFree(&output); } - ret = cipher->doFinal(cipher, NULL, &output); + + ret = cipher->doFinal(cipher, nullptr, &output); if (ret != 0) { LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len); + if (output.data != nullptr) { + if (memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + cipherTextLen += output.len; + HcfBlobDataFree(&output); } - cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + + PrintfHex("plainText", cipherText, cipherTextLen); + if (cipherTextLen != sizeof(plainText) - 1) { + return -1; + } + return memcmp(cipherText, plainText, cipherTextLen); +} + +static int32_t AesNoUpdateEncWithInput(HcfCipher *cipher, HcfSymKey *key, HcfBlob *input, + uint8_t *cipherText, int *cipherTextLen) +{ + HcfBlob output = { .data = nullptr, .len = 0 }; + int32_t maxLen = *cipherTextLen; + int32_t ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! %d", ret); + return ret; + } + + *cipherTextLen = 0; + ret = cipher->doFinal(cipher, input, &output); + if (ret != 0) { + LOGE("doFinal failed!"); + return ret; } - PrintfHex("planText", cipherText, cipherTextLen); - ret = memcmp(cipherText, plainText, cipherTextLen); - ret = ret || (cipherTextLen == sizeof(plainText) - 1) ? 0 : 1; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); + } + + PrintfHex("ciphertext", cipherText, *cipherTextLen); + return 0; +} + +// test encrypt and decrypt with null plain text +static int32_t AesDecryptEmptyMsg(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, + uint8_t *cipherText, int cipherTextLen) +{ + HcfBlob input = { .data = cipherText, .len = cipherTextLen }; + HcfBlob output = { .data = nullptr, .len = 0 }; + int32_t ret = cipher->init(cipher, DECRYPT_MODE, &(key->key), params); + if (ret != 0) { + LOGE("init failed! %d", ret); + return ret; + } + + ret = cipher->doFinal(cipher, &input, &output); + if (ret != 0) { + LOGE("doFinal failed!"); + return ret; + } + if (output.len == 0 && output.data == nullptr) { + ret = 0; + } else { + ret = -1; + } + HcfBlobDataFree(&output); return ret; } @@ -385,14 +501,15 @@ static int32_t AesNoUpdateEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSp LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); - } - *cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + *cipherTextLen += output.len; + HcfBlobDataFree(&output); } + PrintfHex("ciphertext", cipherText, *cipherTextLen); return 0; } @@ -416,19 +533,20 @@ static int32_t AesNoUpdateDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSp LOGE("doFinal failed!"); return ret; } - if (output.len > 0 && output.data != NULL) { - (void)memcpy_s(cipherText, maxLen, output.data, output.len); + if (output.data != nullptr) { + if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) { + HcfBlobDataFree(&output); + return -1; + } + cipherTextLen += output.len; + HcfBlobDataFree(&output); } - cipherTextLen += output.len; - if (output.data != NULL) { - HcfFree(output.data); - output.data = NULL; - output.len = 0; + + PrintfHex("plainText", cipherText, cipherTextLen); + if (cipherTextLen != sizeof(plainText) - 1) { + return -1; } - PrintfHex("planText", cipherText, cipherTextLen); - ret = memcmp(cipherText, plainText, cipherTextLen); - ret = ret || (cipherTextLen == sizeof(plainText) - 1) ? 0 : 1; - return ret; + return memcmp(cipherText, plainText, cipherTextLen); } /** @@ -443,43 +561,43 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest001, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -495,42 +613,42 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest002, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -540,43 +658,43 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest003, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -588,46 +706,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest004, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -639,46 +757,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest005, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -690,46 +808,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest006, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -741,46 +859,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest007, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -792,46 +910,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest008, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -843,46 +961,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest009, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -894,46 +1012,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest010, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -945,46 +1063,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest011, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -996,45 +1114,45 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest012, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1046,46 +1164,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest013, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1097,46 +1215,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest014, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1148,46 +1266,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest015, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1200,46 +1318,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest016, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB1|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1251,46 +1369,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest017, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1302,16 +1420,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest018, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1322,25 +1440,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest018, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1352,16 +1470,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest019, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1372,25 +1490,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest019, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1402,16 +1520,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest020, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1422,25 +1540,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest020, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1452,16 +1570,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest021, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1472,25 +1590,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest021, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1502,16 +1620,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest022, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1522,25 +1640,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest022, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1552,16 +1670,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest023, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1572,25 +1690,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest023, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1602,16 +1720,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest024, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -1622,25 +1740,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest024, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -1653,8 +1771,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -1667,19 +1785,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -1689,12 +1807,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -1707,8 +1825,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -1721,19 +1839,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -1743,12 +1861,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -1761,8 +1879,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -1775,19 +1893,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -1797,12 +1915,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -1815,8 +1933,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -1828,19 +1946,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -1850,12 +1968,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -1868,8 +1986,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -1881,19 +1999,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -1903,16 +2021,15 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } - HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0) { int ret = 0; @@ -1922,8 +2039,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -1935,19 +2052,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -1957,12 +2074,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0) ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -1972,8 +2089,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest031, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t codeCipherText[] = { 0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32, 0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE @@ -1982,36 +2099,36 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest031, TestSize.Level0) ret = ConvertSymKey("AES128", &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = memcmp(cipherText, codeCipherText, cipherTextLen); if (ret != 0) { - LOGE("cipherText cpmpare failed!"); - goto clearup; + LOGE("cipherText compare failed!"); + goto CLEAR_UP; } - ret = AesDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -2021,43 +2138,43 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest032, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -2067,42 +2184,42 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest033, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2112,43 +2229,43 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest034, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } - ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2160,46 +2277,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest035, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_NE(ret, 0); } @@ -2211,46 +2328,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest036, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2262,46 +2379,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest037, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2313,46 +2430,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest038, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2364,46 +2481,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest039, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2415,46 +2532,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest040, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2466,46 +2583,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest041, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2517,46 +2634,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest042, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2568,45 +2685,45 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest043, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2618,46 +2735,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest044, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2669,46 +2786,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest045, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2720,46 +2837,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest046, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2772,46 +2889,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest047, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB1|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2823,46 +2940,46 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest048, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); if (ret != 0) { LOGE("generateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2874,16 +2991,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest049, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -2894,25 +3011,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest049, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2924,16 +3041,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest050, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -2944,25 +3061,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest050, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -2974,16 +3091,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest051, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -2994,25 +3111,25 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest051, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -3024,16 +3141,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest052, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -3044,24 +3161,24 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest052, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -3073,16 +3190,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest053, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -3093,24 +3210,24 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest053, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -3122,16 +3239,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest054, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -3142,24 +3259,24 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest054, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -3171,16 +3288,16 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest055, TestSize.Level0) int cipherTextLen = 128; HcfIvParamsSpec ivSpec = {}; - HcfSymKeyGenerator *generator = NULL; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = HcfSymKeyGeneratorCreate("AES128", &generator); if (ret != 0) { LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); - goto clearup; + goto CLEAR_UP; } ret = generator->generateSymKey(generator, &key); @@ -3191,24 +3308,24 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest055, TestSize.Level0) ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)generator); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); EXPECT_EQ(ret, 0); } @@ -3221,8 +3338,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest056, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -3235,19 +3352,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest056, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -3257,12 +3374,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest056, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3275,8 +3392,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest057, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -3289,19 +3406,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest057, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -3311,12 +3428,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest057, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3329,8 +3446,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest058, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfGcmParamsSpec spec = {}; spec.aad.data = aad; @@ -3343,19 +3460,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest058, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|GCM|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 16, cipherText + cipherTextLen - 16, 16); @@ -3365,12 +3482,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest058, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed, ret:%d!", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3383,8 +3500,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest059, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -3396,19 +3513,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest059, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -3418,12 +3535,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest059, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3436,8 +3553,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest060, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -3449,19 +3566,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest060, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|PKCS5", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -3471,12 +3588,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest060, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3490,8 +3607,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest061, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; HcfCcmParamsSpec spec = {}; spec.aad.data = aad; spec.aad.len = sizeof(aad); @@ -3503,19 +3620,19 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest061, TestSize.Level0) ret = GenerateSymKey("AES128", &key); if (ret != 0) { LOGE("GenerateSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CCM|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed!"); - goto clearup; + goto CLEAR_UP; } (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); @@ -3525,12 +3642,12 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest061, TestSize.Level0) ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3540,8 +3657,8 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest062, TestSize.Level0) uint8_t cipherText[128] = {0}; int cipherTextLen = 128; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; uint8_t codeCipherText[] = { 0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32, 0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE @@ -3550,82 +3667,82 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest062, TestSize.Level0) ret = ConvertSymKey("AES128", &key); if (ret != 0) { LOGE("ConvertSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesNoUpdateEncrypt(cipher, key, NULL, cipherText, &cipherTextLen); + ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = memcmp(cipherText, codeCipherText, cipherTextLen); if (ret != 0) { - LOGE("cipherText cpmpare failed!"); - goto clearup; + LOGE("cipherText compare failed!"); + goto CLEAR_UP; } - ret = AesNoUpdateDecrypt(cipher, key, NULL, cipherText, cipherTextLen); + ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest063, TestSize.Level0) { int ret = 0; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); if (ret != 0) { LOGE("GeneratorFile failed!"); - goto clearup; + goto CLEAR_UP; } ret = ConvertSymKey("AES128", &key); if (ret != 0) { LOGE("ConvertSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } - ret = AesMultiBlockEncrypt(cipher, key, NULL); + ret = AesMultiBlockEncrypt(cipher, key, nullptr); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } - ret = AesMultiBlockDecrypt(cipher, key, NULL); + ret = AesMultiBlockDecrypt(cipher, key, nullptr); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = CompareFileContent(); if (ret != 0) { LOGE("CompareFileContent failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3637,47 +3754,47 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest064, TestSize.Level0) ivSpec.iv.data = iv; ivSpec.iv.len = 16; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); if (ret != 0) { LOGE("GeneratorFile failed!"); - goto clearup; + goto CLEAR_UP; } ret = ConvertSymKey("AES128", &key); if (ret != 0) { LOGE("ConvertSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = CompareFileContent(); if (ret != 0) { LOGE("CompareFileContent failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3687,48 +3804,48 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest065, TestSize.Level0) uint8_t iv[16] = {0}; HcfIvParamsSpec ivSpec = {}; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = ConvertSymKey("AES128", &key); if (ret != 0) { LOGE("ConvertSymKey failed!"); - goto clearup; + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); if (ret != 0) { LOGE("GeneratorFile failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = CompareFileContent(); if (ret != 0) { LOGE("CompareFileContent failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3738,48 +3855,48 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest066, TestSize.Level0) uint8_t iv[16] = {0}; HcfIvParamsSpec ivSpec = {}; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = GenerateSymKey("AES128", &key); if (ret != 0) { - LOGE("ConvertSymKey failed!"); - goto clearup; + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); if (ret != 0) { LOGE("GeneratorFile failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = CompareFileContent(); if (ret != 0) { LOGE("CompareFileContent failed!"); - goto clearup; + goto CLEAR_UP; } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); EXPECT_EQ(ret, 0); } @@ -3789,48 +3906,2826 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest067, TestSize.Level0) uint8_t iv[16] = {0}; HcfIvParamsSpec ivSpec = {}; - HcfCipher *cipher = NULL; - HcfSymKey *key = NULL; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; ivSpec.iv.data = iv; ivSpec.iv.len = 16; ret = GenerateSymKey("AES128", &key); if (ret != 0) { - LOGE("ConvertSymKey failed!"); - goto clearup; + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; } ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); if (ret != 0) { LOGE("HcfCipherCreate failed!"); - goto clearup; + goto CLEAR_UP; } ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); if (ret != 0) { LOGE("GeneratorFile failed!"); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateEncrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); if (ret != 0) { LOGE("AesNoUpdateDecrypt failed! %d", ret); - goto clearup; + goto CLEAR_UP; } ret = CompareFileContent(); if (ret != 0) { LOGE("CompareFileContent failed!"); - goto clearup; + goto CLEAR_UP; + } + +CLEAR_UP: + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest068, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|ECB|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest069, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + key->clearMem(key); +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest070, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|ECB|PKCS7", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + key->clearMem(key); +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest071, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CBC|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest072, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CBC|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest073, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CTR|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); } -clearup: - OH_HCF_OBJ_DESTROY((HcfObjectBase *)key); - OH_HCF_OBJ_DESTROY((HcfObjectBase *)cipher); +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); EXPECT_EQ(ret, 0); } + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest074, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CTR|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest075, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|OFB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest076, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|OFB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest077, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CFB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest078, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CFB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest079, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CFB1|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest080, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CFB1|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest081, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest082, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest083, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest084, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[AES_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfIvParamsSpec ivSpec = {}; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + ivSpec.iv.data = iv; + ivSpec.iv.len = AES_IV_LEN; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest085, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[GCM_AAD_LEN] = { 0 }; + uint8_t tag[GCM_TAG_LEN] = { 0 }; + uint8_t iv[GCM_IV_LEN] = { 0 }; // openssl only support nonce 12 bytes, tag 16 bytes + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + HcfGcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|GCM|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed, ret:%d!", ret); + goto CLEAR_UP; + } + + (void)memcpy_s(spec.tag.data, GCM_TAG_LEN, cipherText + cipherTextLen - GCM_TAG_LEN, GCM_TAG_LEN); + PrintfHex("gcm tag", spec.tag.data, spec.tag.len); + cipherTextLen -= GCM_TAG_LEN; + + ret = AesDecrypt(cipher, key, &(spec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed, ret:%d!", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest086, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[GCM_AAD_LEN] = { 0 }; + uint8_t tag[GCM_TAG_LEN] = { 0 }; + uint8_t iv[GCM_IV_LEN] = { 0 }; // openssl only support nonce 12 bytes, tag 16 bytes + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + HcfGcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|GCM|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed, ret:%d!", ret); + goto CLEAR_UP; + } + + (void)memcpy_s(spec.tag.data, GCM_TAG_LEN, cipherText + cipherTextLen - GCM_TAG_LEN, GCM_TAG_LEN); + PrintfHex("gcm tag", spec.tag.data, spec.tag.len); + cipherTextLen -= GCM_TAG_LEN; + + ret = AesDecrypt(cipher, key, &(spec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed, ret:%d!", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest087, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[CCM_AAD_LEN] = { 0 }; + uint8_t tag[CCM_TAG_LEN] = { 0 }; + uint8_t iv[CCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfCcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES192", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES192|CCM|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + goto CLEAR_UP; + } + + (void)memcpy_s(spec.tag.data, CCM_TAG_LEN, cipherText + cipherTextLen - CCM_TAG_LEN, CCM_TAG_LEN); + PrintfHex("ccm tag", spec.tag.data, spec.tag.len); + cipherTextLen -= CCM_TAG_LEN; + + ret = AesDecrypt(cipher, key, &(spec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest088, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[CCM_AAD_LEN] = { 0 }; + uint8_t tag[CCM_TAG_LEN] = { 0 }; + uint8_t iv[CCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfCcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|CCM|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + goto CLEAR_UP; + } + + (void)memcpy_s(spec.tag.data, CCM_TAG_LEN, cipherText + cipherTextLen - CCM_TAG_LEN, CCM_TAG_LEN); + PrintfHex("ccm tag", spec.tag.data, spec.tag.len); + cipherTextLen -= CCM_TAG_LEN; + + ret = AesDecrypt(cipher, key, &(spec.base), cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest089, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + const char *cipherName = "AES128|CFB|NoPadding"; + const char *retAlgo = nullptr; + ret = HcfCipherCreate(cipherName, &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + retAlgo = cipher->getAlgorithm(cipher); + if (retAlgo == nullptr) { + LOGE("cipher getAlgorithm failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + goto CLEAR_UP; + } + + ret = strcmp(retAlgo, cipherName); + if (ret != 0) { + LOGE("cipher getAlgorithm failed!"); + } +CLEAR_UP: + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest090, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + const char *cipherName = "AES128|CFB|NoPadding"; + const char *retAlgo = nullptr; + ret = HcfCipherCreate(cipherName, &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + retAlgo = cipher->getAlgorithm(nullptr); + if (retAlgo == nullptr) { + LOGE("cipher getAlgorithm failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest091, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKeyGenerator *generator = nullptr; + const char *cipherName = "AES128|CFB|NoPadding"; + const char *retAlgo = nullptr; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + + ret = HcfCipherCreate(cipherName, &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + retAlgo = cipher->getAlgorithm(reinterpret_cast(generator)); + if (retAlgo == nullptr) { + LOGE("cipher getAlgorithm failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest092, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + const char *inputAlgoName = "AES128"; + const char *generatorAlgoName = nullptr; + + ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // generator getAlgoName + generatorAlgoName = generator->getAlgoName(generator); + if (generatorAlgoName == nullptr) { + LOGE("generator getAlgoName returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + goto CLEAR_UP; + } + + ret = strcmp(generatorAlgoName, inputAlgoName); + if (ret != 0) { + LOGE("generator getAlgoName failed!"); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest093, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + const char *generatorAlgoName = nullptr; + const char *inputAlgoName = "AES128"; + + ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + + // generator getAlgoName + generatorAlgoName = generator->getAlgoName(nullptr); + if (generatorAlgoName == nullptr) { + LOGE("generator getAlgoName failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest094, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + const char *generatorAlgoName = nullptr; + const char *inputAlgoName = "AES128"; + + ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // generator getAlgoName + generatorAlgoName = generator->getAlgoName(reinterpret_cast(key)); + if (generatorAlgoName == nullptr) { + LOGE("generator getAlgoName failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest095, TestSize.Level0) +{ + int ret = 0; + HcfSymKey *key = nullptr; + const char *inputAlgoName = "AES128"; + const char *keyAlgoName = nullptr; + + ret = GenerateSymKey(inputAlgoName, &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // key getAlgorithm + keyAlgoName = key->key.getAlgorithm(&(key->key)); + if (keyAlgoName == nullptr) { + LOGE("key getAlgorithm returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + goto CLEAR_UP; + } + + ret = strcmp(keyAlgoName, inputAlgoName); + if (ret != 0) { + LOGE("key getAlgorithm failed!"); + } +CLEAR_UP: + HcfObjDestroy(key); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest096, TestSize.Level0) +{ + int ret = 0; + HcfSymKey *key = nullptr; + const char *inputAlgoName = "AES128"; + const char *keyAlgoName = nullptr; + + ret = GenerateSymKey(inputAlgoName, &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // key getAlgorithm + keyAlgoName = key->key.getAlgorithm(nullptr); + if (keyAlgoName == nullptr) { + LOGE("key getAlgorithm returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest097, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + const char *inputAlgoName = "AES128"; + const char *keyAlgoName = nullptr; + + ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // key getAlgorithm + keyAlgoName = key->key.getAlgorithm(reinterpret_cast(generator)); + if (keyAlgoName == nullptr) { + LOGE("key getAlgorithm returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest098, TestSize.Level0) +{ + int ret = 0; + HcfSymKey *key = nullptr; + const char *keyFormat = "PKCS#8"; + const char *retFormat = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // key GetFormat + retFormat = key->key.getFormat(&(key->key)); + if (retFormat == nullptr) { + LOGE("key GetFormat returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + goto CLEAR_UP; + } + + ret = strcmp(retFormat, keyFormat); + if (ret != 0) { + LOGE("key GetFormat failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest099, TestSize.Level0) +{ + int ret = 0; + HcfSymKey *key = nullptr; + const char *retFormat = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // key getFormat + retFormat = key->key.getFormat(nullptr); + if (retFormat == nullptr) { + LOGE("key GetFormat returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest100, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + const char *retFormat = nullptr; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // key getFormat + retFormat = key->key.getFormat(reinterpret_cast(generator)); + if (retFormat == nullptr) { + LOGE("key GetFormat returns nullptr."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest101, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfBlob encodedBlob = { 0 }; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // key getEncoded + ret = key->key.getEncoded(&(key->key), &encodedBlob); + if (ret != 0) { + LOGE("key GetEncoded failed."); + goto CLEAR_UP; + } + + if (encodedBlob.len != keyTmpBlob.len) { + LOGE("key GetEncoded failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + goto CLEAR_UP; + } + ret = memcmp(encodedBlob.data, keyTmpBlob.data, keyTmpBlob.len); + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + if (encodedBlob.data != nullptr) { + HcfFree(encodedBlob.data); + encodedBlob.data = nullptr; + } + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest102, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfBlob encodedBlob = { 0 }; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // key getEncoded + ret = key->key.getEncoded(nullptr, &encodedBlob); + if (ret != 0) { + LOGE("key GetEncoded failed."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + if (encodedBlob.data != nullptr) { + HcfFree(encodedBlob.data); + encodedBlob.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest103, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfBlob encodedBlob = { 0 }; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + // key getEncoded + ret = key->key.getEncoded(reinterpret_cast(generator), &encodedBlob); + if (ret != 0) { + LOGE("key GetEncoded failed."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + if (encodedBlob.data != nullptr) { + HcfFree(encodedBlob.data); + encodedBlob.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest104, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfBlob encodedBlob = { 0 }; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + SymKeyImpl *impl = nullptr; + size_t tmpLen = 0; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + impl = reinterpret_cast(key); + tmpLen = impl->keyMaterial.len; + impl->keyMaterial.len = 0; + + // key getEncoded + ret = key->key.getEncoded(&(key->key), &encodedBlob); + impl->keyMaterial.len = tmpLen; + if (ret != 0) { + LOGE("key GetEncoded failed."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + if (encodedBlob.data != nullptr) { + HcfFree(encodedBlob.data); + encodedBlob.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest105, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfBlob encodedBlob = { 0 }; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + key->clearMem(nullptr); + + ret = key->key.getEncoded(&(key->key), &encodedBlob); + if (ret != 0) { + LOGE("key GetEncoded failed."); + goto CLEAR_UP; + } + if ((encodedBlob.data != nullptr) && (encodedBlob.data[0] != '\0')) { + LOGE("clearMem failed!"); + ret = HCF_ERR_CRYPTO_OPERATION; + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + if (encodedBlob.data != nullptr) { + HcfFree(encodedBlob.data); + encodedBlob.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest106, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + + ret = HcfSymKeyGeneratorCreate("RSA128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator."); + } + + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest107, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + + ret = HcfSymKeyGeneratorCreate("RSA512", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator."); + } + + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest108, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + + ret = HcfSymKeyGeneratorCreate("", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed! Should not select empty string for symKey generator."); + } + + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest109, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + + ret = HcfSymKeyGeneratorCreate(nullptr, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed! Should not select nullptr for symKey generator."); + } + + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest110, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + + ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorSpiCreate failed!"); + } + + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest111, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(nullptr, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest112, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(reinterpret_cast(cipher), &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest113, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + + ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest114, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + + ret = generator->convertSymKey(reinterpret_cast(cipher), &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest115, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 }; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + + ret = generator->convertSymKey(generator, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest116, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate("RSA128|GCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed! Should not select RSA for GCM generator."); + } + + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest117, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // allow input without encryption mode. It will pick the last PKCS5, and use default aes128ecb. + ret = HcfCipherCreate("AES128|NoPadding|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest118, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + + // not allow '|' without content, because findAbility will fail for "" input + ret = HcfCipherCreate("AES128|GCM|", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed! Should select padding mode for AES generator."); + } + + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest119, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // allow input without encryption mode. It will use default aes128ecb. + ret = HcfCipherCreate("AES128|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest120, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // allow input without encryption mode. It will use default aes128ecb. + ret = HcfCipherCreate("AES128", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest121, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate("", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + } + + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest122, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate(nullptr, &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + } + + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest123, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // allow input with more than one padding mode. It will pick the last PKCS5. + ret = HcfCipherCreate("AES128|ECB|NoPadding|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest124, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES256|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + // It is not allowed that AES128 in key is smaller AES256 in cipher. + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest125, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES256", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest126, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + // CBC, CTR, OFB, CFB enc/dec success, + // GCM, CCM enc/dec failed with params set to nullptr. + ret = HcfCipherCreate("AES128|GCM|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest127, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("GenerateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! Should input cipher when init."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest128, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr); + if (ret != 0) { + LOGE("init failed! Should input key when init."); + } + +CLEAR_UP: + HcfObjDestroy(cipher); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest129, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfCipher *cipher = nullptr; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->generateSymKey(generator, &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(reinterpret_cast(generator), ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed! Should input key when init."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest130, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[GCM_AAD_LEN] = { 0 }; + uint8_t tag[GCM_TAG_LEN] = { 0 }; + uint8_t iv[GCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + HcfGcmParamsSpec spec = {}; + spec.aad.data = nullptr; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|GCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed, ret:%d!", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest131, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[GCM_AAD_LEN] = { 0 }; + uint8_t tag[GCM_TAG_LEN] = { 0 }; + uint8_t iv[GCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + HcfGcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = nullptr; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|GCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed, ret:%d!", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest132, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[GCM_AAD_LEN] = { 0 }; + uint8_t tag[GCM_TAG_LEN] = { 0 }; + uint8_t iv[GCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + HcfGcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = nullptr; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|GCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed, ret:%d!", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest133, TestSize.Level0) +{ + int ret = 0; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest134, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[CCM_AAD_LEN] = { 0 }; + uint8_t tag[CCM_TAG_LEN] = { 0 }; + uint8_t iv[CCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfCcmParamsSpec spec = {}; + spec.aad.data = nullptr; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest135, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[CCM_AAD_LEN] = { 0 }; + uint8_t tag[CCM_TAG_LEN] = { 0 }; + uint8_t iv[CCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfCcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = tag; + spec.tag.len = sizeof(tag); + spec.iv.data = nullptr; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest136, TestSize.Level0) +{ + int ret = 0; + uint8_t aad[CCM_AAD_LEN] = { 0 }; + uint8_t tag[CCM_TAG_LEN] = { 0 }; + uint8_t iv[CCM_IV_LEN] = { 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfCcmParamsSpec spec = {}; + spec.aad.data = aad; + spec.aad.len = sizeof(aad); + spec.tag.data = nullptr; + spec.tag.len = sizeof(tag); + spec.iv.data = iv; + spec.iv.len = sizeof(iv); + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|CCM|NoPadding", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncrypt(cipher, key, &(spec.base), cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest137, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest138, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob input = { .data = nullptr, .len = 0 }; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest139, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed!"); + goto CLEAR_UP; + } + + ret = cipher->update(nullptr, &input, &output); + if (ret != 0) { + LOGE("update failed! Blob data should not be nullptr."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest140, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed!"); + goto CLEAR_UP; + } + + ret = cipher->update(reinterpret_cast(key), &input, &output); + if (ret != 0) { + LOGE("update failed! Blob data should not be nullptr."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest141, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; + int cipherTextLen = CIPHER_TEXT_LEN; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = AesNoUpdateEncWithInput(cipher, key, nullptr, cipherText, &cipherTextLen); + if (ret != 0) { + LOGE("AesEncrypt failed! %d", ret); + goto CLEAR_UP; + } + + ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); + if (ret != 0) { + LOGE("AesDecrypt failed! %d", ret); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_EQ(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest142, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed!"); + goto CLEAR_UP; + } + + ret = cipher->doFinal(cipher, &input, nullptr); + if (ret != 0) { + LOGE("update failed! Blob data should not be nullptr."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest143, TestSize.Level0) +{ + int ret = 0; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + uint8_t plainText[] = "this is test!"; + HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; + HcfBlob output = { .data = nullptr, .len = 0 }; + + ret = GenerateSymKey("AES128", &key); + if (ret != 0) { + LOGE("generateSymKey failed!"); + goto CLEAR_UP; + } + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + + ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); + if (ret != 0) { + LOGE("init failed!"); + goto CLEAR_UP; + } + + ret = cipher->doFinal(reinterpret_cast(key), &input, &output); + if (ret != 0) { + LOGE("update failed! Blob data should not be nullptr."); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(cipher); + if (output.data != nullptr) { + HcfFree(output.data); + output.data = nullptr; + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest144, TestSize.Level0) +{ + int ret = HcfCipherAesGeneratorSpiCreate(nullptr, nullptr); + if (ret != 0) { + LOGE("HcfCipherAesGeneratorSpiCreate failed!"); + } + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest145, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGeneratorSpi *generator = nullptr; + HcfSymKey *key = nullptr; + SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; + + ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->engineGenerateSymmKey(nullptr, &key); + if (ret != 0) { + LOGE("engineGenerateSymmKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest146, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGeneratorSpi *generator = nullptr; + HcfSymKey *key = nullptr; + HcfCipher *cipher = nullptr; + SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->engineGenerateSymmKey(reinterpret_cast(cipher), &key); + if (ret != 0) { + LOGE("engineGenerateSymmKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest147, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGeneratorSpi *generator = nullptr; + HcfSymKey *key = nullptr; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; + + ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->engineConvertSymmKey(nullptr, &keyTmpBlob, &key); + if (ret != 0) { + LOGE("engineConvertSymmKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + EXPECT_NE(ret, 0); +} + +HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest148, TestSize.Level0) +{ + int ret = 0; + HcfSymKeyGeneratorSpi *generator = nullptr; + HcfSymKey *key = nullptr; + uint8_t keyMaterial[] = { + 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, + 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c + }; + HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; + HcfCipher *cipher = nullptr; + SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; + + ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); + if (ret != 0) { + LOGE("HcfCipherCreate failed!"); + goto CLEAR_UP; + } + ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); + if (ret != 0) { + LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); + goto CLEAR_UP; + } + ret = generator->engineConvertSymmKey(reinterpret_cast(cipher), &keyTmpBlob, &key); + if (ret != 0) { + LOGE("engineConvertSymmKey failed!"); + } + +CLEAR_UP: + HcfObjDestroy(key); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + EXPECT_NE(ret, 0); +} } \ No newline at end of file diff --git a/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp b/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp index 66d5f25080975d24a53cfb3736389bde94f00b69..3800651492daff6339e5ec622057518ba3c5a9f7 100644 --- a/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -17,7 +17,11 @@ #include "securec.h" #include "asy_key_generator.h" +#include "ecc_asy_key_generator_openssl.h" #include "blob.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "params_parser.h" using namespace std; using namespace testing::ext; @@ -36,88 +40,97 @@ void CryptoEccAsyKeyGeneratorTest::TearDownTestCase() {} void CryptoEccAsyKeyGeneratorTest::SetUp() {} void CryptoEccAsyKeyGeneratorTest::TearDown() {} -const int ECC224_PUB_KEY_LEN = 57; -const int ECC224_PRI_KEY_LEN = 28; -const int ECC256_PUB_KEY_LEN = 65; -const int ECC256_PRI_KEY_LEN = 32; -const int ECC384_PUB_KEY_LEN = 97; -const int ECC384_PRI_KEY_LEN = 48; -const int ECC512_PUB_KEY_LEN = 133; -const int ECC512_PRI_KEY_LEN = 65; - -static uint8_t mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 4, 189, 186, 122, 21, 9, 8, 231, 90, 111, 68, 222, - 207, 200, 53, 114, 236, 246, 204, 9, 171, 197, 57, 173, 138, 38, 180, 217, 55, 234, 181, 87, 143, 199, 250, 222, - 101, 120, 193, 184, 132, 9, 139, 177, 112, 246, 97, 25, 57, 43, 252, 212, 33, 181, 114, 89, 151 }; - -static uint8_t mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 7, 13, 160, 20, 7, 190, 2, 157, 233, 245, 164, 249, - 218, 30, 241, 3, 198, 136, 155, 15, 168, 198, 237, 117, 95, 45, 142, 183 }; - -static uint8_t mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 4, 15, 195, 182, 51, 78, 219, 41, 100, 231, 64, 119, - 34, 191, 238, 62, 169, 229, 240, 57, 216, 20, 229, 93, 193, 136, 238, 194, 150, 78, 205, 62, 218, 201, 77, 194, - 46, 121, 234, 126, 85, 134, 229, 244, 227, 184, 42, 22, 171, 179, 236, 16, 12, 93, 138, 175, 255, 99, 212, 107, - 83, 128, 49, 194, 215 }; - -static uint8_t mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 218, 130, 176, 177, 252, 163, 236, 3, 204, 22, 211, - 213, 239, 252, 14, 231, 185, 139, 221, 45, 196, 13, 237, 179, 129, 165, 72, 224, 230, 210, 207, 232 }; -static uint8_t mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 4, 246, 111, 226, 33, 39, 150, 111, 50, 96, 228, - 225, 189, 33, 213, 169, 139, 181, 46, 51, 160, 254, 184, 75, 115, 153, 153, 105, 177, 50, 211, 101, 71, 53, - 5, 138, 56, 125, 137, 4, 206, 152, 206, 221, 212, 162, 242, 135, 202, 205, 119, 79, 45, 191, 111, 84, 172, - 34, 159, 112, 149, 197, 102, 56, 235, 212, 171, 234, 162, 11, 188, 146, 137, 203, 180, 46, 241, 44, 235, - 25, 111, 12, 115, 140, 220, 41, 192, 166, 124, 205, 173, 142, 107, 4, 105, 54, 148 }; - -static uint8_t mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 121, 40, 96, 196, 198, 46, 100, 70, 102, 98, 63, 143, - 8, 224, 229, 57, 236, 161, 224, 204, 85, 49, 99, 205, 104, 90, 98, 9, 79, 171, 189, 5, 194, 117, 225, 203, 127, - 17, 214, 77, 6, 99, 162, 9, 191, 192, 76, 174 }; -static uint8_t mockEcc512PubKeyBlobData[ECC512_PUB_KEY_LEN] = { 4, 1, 79, 67, 218, 31, 215, 194, 89, 74, 246, 88, - 151, 232, 47, 159, 60, 56, 23, 159, 12, 123, 12, 239, 81, 75, 92, 15, 118, 101, 27, 69, 147, 76, 151, 91, 59, - 212, 77, 176, 198, 132, 151, 225, 113, 116, 164, 254, 206, 148, 203, 95, 3, 137, 148, 180, 184, 173, 206, 16, - 12, 170, 57, 228, 25, 233, 159, 0, 107, 24, 217, 155, 26, 85, 40, 148, 116, 97, 134, 150, 73, 127, 247, 184, - 132, 188, 2, 165, 236, 146, 150, 103, 213, 206, 185, 124, 13, 166, 213, 238, 39, 18, 10, 164, 226, 139, 86, - 159, 25, 88, 154, 155, 75, 248, 46, 200, 14, 33, 45, 68, 4, 238, 138, 144, 114, 11, 219, 114, 7, 163, 255, 9, 150 }; - -static uint8_t mockEcc512PriKeyBlobData[ECC512_PRI_KEY_LEN] = { 128, 210, 9, 28, 225, 87, 232, 88, 102, 55, 78, 216, - 162, 210, 219, 218, 26, 33, 206, 253, 165, 172, 111, 60, 157, 206, 77, 145, 123, 95, 92, 21, 254, 159, 145, 104, - 194, 49, 0, 108, 38, 40, 204, 1, 231, 162, 34, 64, 118, 191, 163, 143, 33, 44, 55, 231, 54, 64, 210, 54, 201, - 117, 251, 157, 109 }; - -static HcfBlob mockEcc224PubKeyBlob = { - .data = mockEcc224PubKeyBlobData, +const int ECC224_PUB_KEY_LEN = 80; +const int ECC224_PRI_KEY_LEN = 44; +const int ECC256_PUB_KEY_LEN = 91; +const int ECC256_PRI_KEY_LEN = 51; +const int ECC384_PUB_KEY_LEN = 120; +const int ECC384_PRI_KEY_LEN = 64; +const int ECC521_PUB_KEY_LEN = 158; +const int ECC521_PRI_KEY_LEN = 82; + +uint8_t g_mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, + 6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207, 141, 146, + 235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181, 172, 192, 2, + 99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 }; + +uint8_t g_mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, 147, 222, 43, + 252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198, 19, 160, 7, 6, + 5, 43, 129, 4, 0, 33 }; + +uint8_t g_mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, + 6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 3, 66, 0, 4, 65, 43, 59, 227, 32, 51, 44, 104, 47, 135, 97, 144, 91, 70, + 231, 67, 2, 214, 197, 176, 161, 160, 227, 133, 158, 30, 118, 217, 243, 155, 88, 55, 214, 86, 86, 122, 166, 64, + 111, 2, 226, 93, 163, 194, 210, 74, 18, 63, 173, 113, 249, 196, 126, 165, 222, 230, 190, 101, 241, 95, 102, 174, + 252, 38 }; + +uint8_t g_mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45, + 68, 72, 231, 43, 72, 243, 113, 255, 60, 232, 203, 151, 65, 80, 6, 36, 112, 247, 186, 106, 148, 43, 170, 204, + 23, 189, 191, 160, 10, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7 }; + +uint8_t g_mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 48, 118, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, + 1, 6, 5, 43, 129, 4, 0, 34, 3, 98, 0, 4, 149, 237, 84, 7, 62, 114, 48, 106, 64, 227, 243, 253, 90, 170, 184, + 80, 174, 159, 72, 117, 16, 24, 213, 146, 184, 159, 33, 209, 36, 143, 227, 11, 113, 228, 128, 13, 181, 195, 235, + 12, 255, 85, 187, 197, 109, 82, 242, 226, 186, 53, 128, 9, 133, 4, 170, 96, 150, 94, 197, 196, 107, 120, 55, + 159, 181, 208, 249, 176, 108, 6, 166, 253, 221, 156, 139, 140, 124, 240, 11, 194, 154, 139, 62, 218, 170, 61, + 12, 147, 7, 146, 243, 158, 103, 195, 123, 156 }; + +uint8_t g_mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 48, 62, 2, 1, 1, 4, 48, 137, 184, 12, 183, 201, + 211, 124, 203, 165, 9, 229, 68, 46, 17, 14, 14, 109, 195, 0, 206, 248, 21, 53, 72, 66, 3, 244, 165, 248, + 217, 176, 121, 155, 225, 222, 134, 155, 241, 59, 16, 253, 237, 158, 11, 221, 252, 58, 251, 160, 7, 6, 5, + 43, 129, 4, 0, 34 }; + +uint8_t g_mockEcc521PubKeyBlobData[ECC521_PUB_KEY_LEN] = { 48, 129, 155, 48, 16, 6, 7, 42, 134, 72, 206, + 61, 2, 1, 6, 5, 43, 129, 4, 0, 35, 3, 129, 134, 0, 4, 0, 149, 60, 46, 252, 220, 227, 253, 219, 250, 60, 232, + 80, 190, 119, 38, 79, 202, 173, 35, 126, 228, 244, 207, 174, 191, 250, 147, 188, 22, 132, 125, 44, 26, 57, 242, + 203, 192, 100, 65, 185, 250, 80, 246, 76, 37, 242, 78, 64, 152, 47, 172, 165, 229, 99, 247, 61, 91, 152, 144, + 67, 34, 38, 130, 198, 22, 0, 179, 69, 69, 147, 72, 154, 76, 134, 28, 158, 33, 251, 94, 63, 77, 44, 100, 132, + 207, 159, 210, 113, 194, 174, 170, 194, 129, 215, 209, 50, 217, 204, 48, 53, 92, 231, 57, 179, 170, 6, 26, 77, + 187, 181, 35, 254, 17, 216, 205, 118, 104, 89, 155, 145, 28, 61, 169, 113, 195, 55, 13, 125, 6, 168, 156 }; + +uint8_t g_mockEcc521PriKeyBlobData[ECC521_PRI_KEY_LEN] = { 48, 80, 2, 1, 1, 4, 66, 0, 210, 135, 140, 70, + 98, 28, 121, 169, 5, 202, 132, 165, 11, 56, 9, 110, 32, 9, 146, 185, 239, 69, 113, 79, 213, 24, 165, 194, 147, + 209, 223, 187, 100, 6, 149, 4, 56, 235, 120, 152, 146, 252, 92, 21, 222, 3, 182, 68, 39, 222, 49, 192, 154, 126, + 126, 243, 18, 99, 136, 199, 234, 134, 232, 13, 128, 160, 7, 6, 5, 43, 129, 4, 0, 35 }; + +HcfBlob g_mockEcc224PubKeyBlob = { + .data = g_mockEcc224PubKeyBlobData, .len = ECC224_PUB_KEY_LEN }; -static HcfBlob mockEcc224PriKeyBlob = { - .data = mockEcc224PriKeyBlobData, +HcfBlob g_mockEcc224PriKeyBlob = { + .data = g_mockEcc224PriKeyBlobData, .len = ECC224_PRI_KEY_LEN }; -static HcfBlob mockEcc256PubKeyBlob = { - .data = mockEcc256PubKeyBlobData, +HcfBlob g_mockEcc256PubKeyBlob = { + .data = g_mockEcc256PubKeyBlobData, .len = ECC256_PUB_KEY_LEN }; -static HcfBlob mockEcc256PriKeyBlob = { - .data = mockEcc256PriKeyBlobData, +HcfBlob g_mockEcc256PriKeyBlob = { + .data = g_mockEcc256PriKeyBlobData, .len = ECC256_PRI_KEY_LEN }; -static HcfBlob mockEcc384PubKeyBlob = { - .data = mockEcc384PubKeyBlobData, +HcfBlob g_mockEcc384PubKeyBlob = { + .data = g_mockEcc384PubKeyBlobData, .len = ECC384_PUB_KEY_LEN }; -static HcfBlob mockEcc384PriKeyBlob = { - .data = mockEcc384PriKeyBlobData, +HcfBlob g_mockEcc384PriKeyBlob = { + .data = g_mockEcc384PriKeyBlobData, .len = ECC384_PRI_KEY_LEN }; -static HcfBlob mockEcc512PubKeyBlob = { - .data = mockEcc512PubKeyBlobData, - .len = ECC512_PUB_KEY_LEN +HcfBlob g_mockEcc521PubKeyBlob = { + .data = g_mockEcc521PubKeyBlobData, + .len = ECC521_PUB_KEY_LEN }; -static HcfBlob mockEcc512PriKeyBlob = { - .data = mockEcc512PriKeyBlobData, - .len = ECC512_PRI_KEY_LEN +HcfBlob g_mockEcc521PriKeyBlob = { + .data = g_mockEcc521PriKeyBlobData, + .len = ECC521_PRI_KEY_LEN }; static const char *GetMockClass(void) @@ -125,9 +138,9 @@ static const char *GetMockClass(void) return "HcfSymKeyGenerator"; } -static HcfObjectBase obj = { +HcfObjectBase g_obj = { .getClass = GetMockClass, - .destroy = NULL + .destroy = nullptr }; /** @@ -138,51 +151,51 @@ static HcfObjectBase obj = { */ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest001, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest002, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest003, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest004, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; - int32_t res = HcfAsyKeyGeneratorCreate("ECC512", &generator); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest005, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate(nullptr, &generator); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -191,7 +204,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest005, TestSize HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest006, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD" "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &generator); @@ -201,7 +214,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest006, TestSize HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest007, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC225", &generator); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -210,14 +223,14 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest007, TestSize HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest008, TestSize.Level0) { - int32_t res = HcfAsyKeyGeneratorCreate("ECC224", NULL); + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest101, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); @@ -226,12 +239,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest101, TestSize const char *className = generator->base.getClass(); ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest102, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); @@ -242,33 +255,33 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest102, TestSize HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest103, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - generator->base.destroy(NULL); + generator->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest104, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - generator->base.destroy(&obj); + generator->base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest105, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); @@ -278,167 +291,167 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest105, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest106, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - const char *algName = generator->getAlgoName(NULL); + const char *algName = generator->getAlgoName(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest107, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&obj); + const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest201, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest202, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest203, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest204, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; - int32_t res = HcfAsyKeyGeneratorCreate("ECC512", &generator); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest205, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(NULL, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(nullptr, nullptr, &keyPair); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest206, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair((HcfAsyKeyGenerator *)&obj, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest207, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - res = generator->generateKeyPair(generator, NULL, NULL); + res = generator->generateKeyPair(generator, nullptr, nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest301, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -447,67 +460,67 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest301, TestSize ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest302, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest303, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(NULL); + keyPair->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest304, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(&obj); + keyPair->base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest305, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -515,69 +528,69 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest305, TestSize const char *className = keyPair->pubKey->base.base.getClass(); ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest306, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base))); - keyPair->pubKey = NULL; + keyPair->pubKey = nullptr; - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest307, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(NULL); + keyPair->pubKey->base.base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest308, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(&obj); + keyPair->pubKey->base.base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest309, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -586,55 +599,55 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest309, TestSize ASSERT_NE(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest310, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat(NULL); + const char *format = keyPair->pubKey->base.getFormat(nullptr); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest311, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest312, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -643,61 +656,61 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest312, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest313, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm(NULL); + const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest314, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest315, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob); @@ -708,137 +721,137 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest315, TestSize free(blob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest316, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->pubKey->base.getEncoded(NULL, &blob); + res = keyPair->pubKey->base.getEncoded(nullptr, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest317, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->pubKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest318, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), NULL); + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr); ASSERT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest319, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->priKey->clearMem(keyPair->priKey); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest320, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem(NULL); + keyPair->priKey->clearMem(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest321, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem((HcfPriKey *)&obj); + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest322, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -847,69 +860,69 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest322, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest323, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base))); - keyPair->priKey = NULL; + keyPair->priKey = nullptr; - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest324, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(NULL); + keyPair->priKey->base.base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest325, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(&obj); + keyPair->priKey->base.base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest326, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -918,55 +931,55 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest326, TestSize ASSERT_NE(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest327, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat(NULL); + const char *format = keyPair->priKey->base.getFormat(nullptr); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest328, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest329, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -975,61 +988,61 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest329, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest330, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm(NULL); + const char *algName = keyPair->priKey->base.getAlgorithm(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest331, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest332, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob); @@ -1040,231 +1053,231 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest332, TestSize free(blob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest333, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->priKey->base.getEncoded(NULL, &blob); + res = keyPair->priKey->base.getEncoded(nullptr, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest334, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->priKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest335, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), NULL); + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr); ASSERT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest401, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest402, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc256PubKeyBlob, &mockEcc256PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc256PubKeyBlob, &g_mockEcc256PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest403, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc384PubKeyBlob, &mockEcc384PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc384PubKeyBlob, &g_mockEcc384PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest404, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; - int32_t res = HcfAsyKeyGeneratorCreate("ECC512", &generator); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc512PubKeyBlob, &mockEcc512PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc521PubKeyBlob, &g_mockEcc521PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest405, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(NULL, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(nullptr, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest406, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey((HcfAsyKeyGenerator *)&obj, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, - &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, + &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest407, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, NULL, &mockEcc224PriKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest408, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, NULL, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, nullptr, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest409, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, NULL, NULL, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, nullptr, &outKeyPair); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(outKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest410, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, NULL); + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, nullptr); ASSERT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest501, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1273,67 +1286,67 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest501, TestSize ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest502, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest503, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(NULL); + keyPair->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest504, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(&obj); + keyPair->base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest505, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1341,69 +1354,69 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest505, TestSize const char *className = keyPair->pubKey->base.base.getClass(); ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest506, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base))); - keyPair->pubKey = NULL; + keyPair->pubKey = nullptr; - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest507, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(NULL); + keyPair->pubKey->base.base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest508, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(&obj); + keyPair->pubKey->base.base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest509, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1412,55 +1425,55 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest509, TestSize ASSERT_NE(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest510, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat(NULL); + const char *format = keyPair->pubKey->base.getFormat(nullptr); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest511, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest512, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1469,61 +1482,61 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest512, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest513, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm(NULL); + const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest514, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest515, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob); @@ -1534,137 +1547,137 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest515, TestSize free(blob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest516, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->pubKey->base.getEncoded(NULL, &blob); + res = keyPair->pubKey->base.getEncoded(nullptr, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest517, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->pubKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest518, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), NULL); + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr); ASSERT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest519, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->priKey->clearMem(keyPair->priKey); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest520, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem(NULL); + keyPair->priKey->clearMem(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest521, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem((HcfPriKey *)&obj); + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest522, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1673,69 +1686,69 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest522, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest523, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base))); - keyPair->priKey = NULL; + keyPair->priKey = nullptr; - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest524, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(NULL); + keyPair->priKey->base.base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest525, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(&obj); + keyPair->priKey->base.base.destroy(&g_obj); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest526, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1744,55 +1757,55 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest526, TestSize ASSERT_NE(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest527, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat(NULL); + const char *format = keyPair->priKey->base.getFormat(nullptr); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest528, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest529, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1801,61 +1814,61 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest529, TestSize ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest530, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm(NULL); + const char *algName = keyPair->priKey->base.getAlgorithm(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest531, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest532, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob); @@ -1866,92 +1879,92 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest532, TestSize free(blob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest533, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->priKey->base.getEncoded(NULL, &blob); + res = keyPair->priKey->base.getEncoded(nullptr, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest534, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob blob = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyPair->priKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); ASSERT_EQ(blob.len, 0); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest535, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), NULL); + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr); ASSERT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob pubKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); @@ -1959,21 +1972,21 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize ASSERT_EQ(res, HCF_SUCCESS); HcfBlob priKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); ASSERT_EQ(res, HCF_SUCCESS); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); HcfBlob outPubKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob); @@ -1983,7 +1996,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize ASSERT_NE(outPubKeyBlob.len, 0); HcfBlob outPriKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob); @@ -1996,24 +2009,24 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize free(priKeyBlob.data); free(outPubKeyBlob.data); free(outPriKeyBlob.data); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob pubKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); @@ -2022,8 +2035,8 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize ASSERT_NE(pubKeyBlob.data, nullptr); ASSERT_NE(pubKeyBlob.len, 0); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, NULL, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -2031,7 +2044,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize ASSERT_EQ(outKeyPair->priKey, nullptr); HcfBlob outPubKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob); @@ -2042,24 +2055,24 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize free(pubKeyBlob.data); free(outPubKeyBlob.data); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); HcfBlob priKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); @@ -2068,8 +2081,8 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize ASSERT_NE(priKeyBlob.data, nullptr); ASSERT_NE(priKeyBlob.len, 0); - HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, NULL, &priKeyBlob, &outKeyPair); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -2077,7 +2090,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize ASSERT_NE(outKeyPair->priKey, nullptr); HcfBlob outPriKeyBlob = { - .data = NULL, + .data = nullptr, .len = 0 }; res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob); @@ -2088,8 +2101,317 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize free(priKeyBlob.data); free(outPriKeyBlob.data); - OH_HCF_OBJ_DESTROY(outKeyPair); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest601, TestSize.Level0) +{ + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest602, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest603, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_MODE_NONE, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest604, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest605, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, nullptr, nullptr, &keyPair); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest606, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest607, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&g_obj); + + HcfObjDestroy(spiObj); +} + +static void MemoryMallocTestFunc(uint32_t mallocCount) +{ + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfAsyKeyGenerator *tmpGenerator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *tmpKeyPair = nullptr; + res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPubKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPriKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob); + if (res != HCF_SUCCESS) { + free(tmpPubKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfKeyPair *tmpOutKeyPair = nullptr; + res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair); + free(tmpPubKeyBlob.data); + free(tmpPriKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + if (res == HCF_SUCCESS) { + HcfObjDestroy(tmpOutKeyPair); + } + } +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest701, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKeyBlob.data, nullptr); + ASSERT_NE(pubKeyBlob.len, 0); + + HcfBlob priKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKeyBlob.data, nullptr); + ASSERT_NE(priKeyBlob.len, 0); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); + + free(pubKeyBlob.data); + free(priKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + + uint32_t mallocCount = GetMallocNum(); + MemoryMallocTestFunc(mallocCount); + + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount) +{ + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfAsyKeyGenerator *tmpGenerator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *tmpKeyPair = nullptr; + res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPubKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPriKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob); + if (res != HCF_SUCCESS) { + free(tmpPubKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfKeyPair *tmpOutKeyPair = nullptr; + res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair); + free(tmpPubKeyBlob.data); + free(tmpPriKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + if (res == HCF_SUCCESS) { + HcfObjDestroy(tmpOutKeyPair); + } + } +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest702, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKeyBlob.data, nullptr); + ASSERT_NE(pubKeyBlob.len, 0); + + HcfBlob priKeyBlob = { + .data = nullptr, + .len = 0 + }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKeyBlob.data, nullptr); + ASSERT_NE(priKeyBlob.len, 0); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); + + free(pubKeyBlob.data); + free(priKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount); + + EndRecordOpensslCallNum(); } } diff --git a/test/unittest/src/crypto_ecc_key_agreement_test.cpp b/test/unittest/src/crypto_ecc_key_agreement_test.cpp index 96fcf4fbba6474e2452edb344e3eeaee0d2ac9a2..f1657373bfb9e24813f41adbb78b536ff60a909c 100644 --- a/test/unittest/src/crypto_ecc_key_agreement_test.cpp +++ b/test/unittest/src/crypto_ecc_key_agreement_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -17,7 +17,11 @@ #include "securec.h" #include "asy_key_generator.h" +#include "ecdh_openssl.h" #include "key_agreement.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "params_parser.h" using namespace std; using namespace testing::ext; @@ -33,82 +37,82 @@ public: static HcfKeyPair *ecc224KeyPair_; static HcfKeyPair *ecc256KeyPair_; static HcfKeyPair *ecc384KeyPair_; - static HcfKeyPair *ecc512KeyPair_; + static HcfKeyPair *ecc521KeyPair_; }; HcfKeyPair *CryptoEccKeyAgreementTest::ecc224KeyPair_ = nullptr; HcfKeyPair *CryptoEccKeyAgreementTest::ecc256KeyPair_ = nullptr; HcfKeyPair *CryptoEccKeyAgreementTest::ecc384KeyPair_ = nullptr; -HcfKeyPair *CryptoEccKeyAgreementTest::ecc512KeyPair_ = nullptr; +HcfKeyPair *CryptoEccKeyAgreementTest::ecc521KeyPair_ = nullptr; void CryptoEccKeyAgreementTest::SetUp() {} void CryptoEccKeyAgreementTest::TearDown() {} void CryptoEccKeyAgreementTest::SetUpTestCase() { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); ecc224KeyPair_ = keyPair; - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); - HcfAsyKeyGenerator *generator2 = NULL; + HcfAsyKeyGenerator *generator2 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC256", &generator2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator2, nullptr); - HcfKeyPair *keyPair2 = NULL; - res = generator2->generateKeyPair(generator2, NULL, &keyPair2); + HcfKeyPair *keyPair2 = nullptr; + res = generator2->generateKeyPair(generator2, nullptr, &keyPair2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair2, nullptr); ecc256KeyPair_ = keyPair2; - OH_HCF_OBJ_DESTROY(generator2); + HcfObjDestroy(generator2); - HcfAsyKeyGenerator *generator3 = NULL; + HcfAsyKeyGenerator *generator3 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC384", &generator3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator3, nullptr); - HcfKeyPair *keyPair3 = NULL; - res = generator3->generateKeyPair(generator3, NULL, &keyPair3); + HcfKeyPair *keyPair3 = nullptr; + res = generator3->generateKeyPair(generator3, nullptr, &keyPair3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair3, nullptr); ecc384KeyPair_ = keyPair3; - OH_HCF_OBJ_DESTROY(generator3); + HcfObjDestroy(generator3); - HcfAsyKeyGenerator *generator4 = NULL; - res = HcfAsyKeyGeneratorCreate("ECC512", &generator4); + HcfAsyKeyGenerator *generator4 = nullptr; + res = HcfAsyKeyGeneratorCreate("ECC521", &generator4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator4, nullptr); - HcfKeyPair *keyPair4 = NULL; - res = generator4->generateKeyPair(generator4, NULL, &keyPair4); + HcfKeyPair *keyPair4 = nullptr; + res = generator4->generateKeyPair(generator4, nullptr, &keyPair4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair4, nullptr); - ecc512KeyPair_ = keyPair4; + ecc521KeyPair_ = keyPair4; - OH_HCF_OBJ_DESTROY(generator4); + HcfObjDestroy(generator4); } void CryptoEccKeyAgreementTest::TearDownTestCase() { - OH_HCF_OBJ_DESTROY(ecc224KeyPair_); - OH_HCF_OBJ_DESTROY(ecc256KeyPair_); - OH_HCF_OBJ_DESTROY(ecc384KeyPair_); - OH_HCF_OBJ_DESTROY(ecc512KeyPair_); + HcfObjDestroy(ecc224KeyPair_); + HcfObjDestroy(ecc256KeyPair_); + HcfObjDestroy(ecc384KeyPair_); + HcfObjDestroy(ecc521KeyPair_); } static const char *GetMockClass(void) @@ -118,57 +122,57 @@ static const char *GetMockClass(void) static HcfObjectBase obj = { .getClass = GetMockClass, - .destroy = NULL + .destroy = nullptr }; HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest001, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest002, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest003, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest004, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; - int32_t res = HcfKeyAgreementCreate("ECC512", &keyAgreement); + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest005, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; - int32_t res = HcfKeyAgreementCreate(NULL, &keyAgreement); + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate(nullptr, &keyAgreement); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(keyAgreement, nullptr); @@ -176,7 +180,7 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest005, TestSize.Level HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest006, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD" "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &keyAgreement); @@ -186,7 +190,7 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest006, TestSize.Level HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest007, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC257", &keyAgreement); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -195,14 +199,14 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest007, TestSize.Level HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest008, TestSize.Level0) { - int32_t res = HcfKeyAgreementCreate("ECC256", NULL); + int32_t res = HcfKeyAgreementCreate("ECC256", nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest101, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); @@ -212,12 +216,12 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest101, TestSize.Level ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest102, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); @@ -228,20 +232,20 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest102, TestSize.Level HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest103, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - keyAgreement->base.destroy(NULL); + keyAgreement->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest104, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); @@ -249,12 +253,12 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest104, TestSize.Level keyAgreement->base.destroy(&obj); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest105, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); @@ -264,27 +268,27 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest105, TestSize.Level ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest106, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - const char *algName = keyAgreement->getAlgoName(NULL); + const char *algName = keyAgreement->getAlgoName(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest107, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); @@ -294,19 +298,19 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest107, TestSize.Level ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest201, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret(keyAgreement, ecc224KeyPair_->priKey, ecc224KeyPair_->pubKey, &out); @@ -316,19 +320,19 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest201, TestSize.Level ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest202, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); @@ -338,19 +342,19 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest202, TestSize.Level ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest203, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret(keyAgreement, ecc384KeyPair_->priKey, ecc384KeyPair_->pubKey, &out); @@ -360,62 +364,62 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest203, TestSize.Level ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest204, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; - int32_t res = HcfKeyAgreementCreate("ECC512", &keyAgreement); + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyAgreement->generateSecret(keyAgreement, ecc512KeyPair_->priKey, ecc512KeyPair_->pubKey, &out); + res = keyAgreement->generateSecret(keyAgreement, ecc521KeyPair_->priKey, ecc521KeyPair_->pubKey, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest205, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyAgreement->generateSecret(NULL, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + res = keyAgreement->generateSecret(nullptr, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(out.data, nullptr); ASSERT_EQ(out.len, 0); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest206, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret((HcfKeyAgreement *)(&obj), ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); @@ -424,19 +428,19 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest206, TestSize.Level ASSERT_EQ(out.data, nullptr); ASSERT_EQ(out.len, 0); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest207, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret(keyAgreement, (HcfPriKey *)(&obj), ecc256KeyPair_->pubKey, &out); @@ -445,19 +449,19 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest207, TestSize.Level ASSERT_EQ(out.data, nullptr); ASSERT_EQ(out.len, 0); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest208, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, (HcfPubKey *)(&obj), &out); @@ -466,42 +470,279 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest208, TestSize.Level ASSERT_EQ(out.data, nullptr); ASSERT_EQ(out.len, 0); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest209, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = keyAgreement->generateSecret(keyAgreement, NULL, NULL, &out); + res = keyAgreement->generateSecret(keyAgreement, nullptr, nullptr, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(out.data, nullptr); ASSERT_EQ(out.len, 0); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(keyAgreement); } HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest210, TestSize.Level0) { - HcfKeyAgreement *keyAgreement = NULL; + HcfKeyAgreement *keyAgreement = nullptr; int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyAgreement, nullptr); - res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, NULL); + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest301, TestSize.Level0) +{ + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest302, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest303, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_MODE_NONE, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest304, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&obj, + ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest305, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&obj, ecc256KeyPair_->pubKey, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest306, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, (HcfPubKey *)&obj, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(keyAgreement); + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest307, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest308, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest401, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfKeyAgreement *keyAgreement = NULL; + int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(keyAgreement); + + uint32_t mallocCount = GetMallocNum(); + + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + keyAgreement = NULL; + res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + if (res != HCF_SUCCESS) { + continue; + } + + out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyAgreement); + continue; + } + + HcfObjDestroy(keyAgreement); + free(out.data); + } + EndRecordMallocNum(); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest402, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfKeyAgreement *keyAgreement = NULL; + int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(keyAgreement); + + uint32_t mallocCount = GetOpensslCallNum(); + + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + keyAgreement = NULL; + res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + if (res != HCF_SUCCESS) { + continue; + } + + out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyAgreement); + continue; + } + + HcfObjDestroy(keyAgreement); + free(out.data); + } + EndRecordOpensslCallNum(); } } diff --git a/test/unittest/src/crypto_ecc_sign_test.cpp b/test/unittest/src/crypto_ecc_sign_test.cpp index e99e94968b1d9e8edb6a6a7ad4919efef1c969db..d35b7ad0f1987f109308af996dcf281a84df69cd 100644 --- a/test/unittest/src/crypto_ecc_sign_test.cpp +++ b/test/unittest/src/crypto_ecc_sign_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -18,9 +18,12 @@ #include "asy_key_generator.h" #include "blob.h" +#include "ecdsa_openssl.h" #include "memory.h" #include "securec.h" #include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" using namespace std; using namespace testing::ext; @@ -36,17 +39,17 @@ public: static HcfKeyPair *ecc224KeyPair_; static HcfKeyPair *ecc256KeyPair_; static HcfKeyPair *ecc384KeyPair_; - static HcfKeyPair *ecc512KeyPair_; + static HcfKeyPair *ecc521KeyPair_; }; HcfKeyPair *CryptoEccSignTest::ecc224KeyPair_ = nullptr; HcfKeyPair *CryptoEccSignTest::ecc256KeyPair_ = nullptr; HcfKeyPair *CryptoEccSignTest::ecc384KeyPair_ = nullptr; -HcfKeyPair *CryptoEccSignTest::ecc512KeyPair_ = nullptr; +HcfKeyPair *CryptoEccSignTest::ecc521KeyPair_ = nullptr; -static const char *g_mockMessage = "hello world"; -static HcfBlob mockInput = { - .data = (uint8_t *)g_mockMessage, +static const char *MOCK_MESSAGE = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)MOCK_MESSAGE, .len = 12 }; @@ -55,69 +58,69 @@ void CryptoEccSignTest::TearDown() {} void CryptoEccSignTest::SetUpTestCase() { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); ecc224KeyPair_ = keyPair; - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); - HcfAsyKeyGenerator *generator2 = NULL; + HcfAsyKeyGenerator *generator2 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC256", &generator2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator2, nullptr); - HcfKeyPair *keyPair2 = NULL; - res = generator2->generateKeyPair(generator2, NULL, &keyPair2); + HcfKeyPair *keyPair2 = nullptr; + res = generator2->generateKeyPair(generator2, nullptr, &keyPair2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair2, nullptr); ecc256KeyPair_ = keyPair2; - OH_HCF_OBJ_DESTROY(generator2); + HcfObjDestroy(generator2); - HcfAsyKeyGenerator *generator3 = NULL; + HcfAsyKeyGenerator *generator3 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC384", &generator3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator3, nullptr); - HcfKeyPair *keyPair3 = NULL; - res = generator3->generateKeyPair(generator3, NULL, &keyPair3); + HcfKeyPair *keyPair3 = nullptr; + res = generator3->generateKeyPair(generator3, nullptr, &keyPair3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair3, nullptr); ecc384KeyPair_ = keyPair3; - OH_HCF_OBJ_DESTROY(generator3); + HcfObjDestroy(generator3); - HcfAsyKeyGenerator *generator4 = NULL; - res = HcfAsyKeyGeneratorCreate("ECC512", &generator4); + HcfAsyKeyGenerator *generator4 = nullptr; + res = HcfAsyKeyGeneratorCreate("ECC521", &generator4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator4, nullptr); - HcfKeyPair *keyPair4 = NULL; - res = generator4->generateKeyPair(generator4, NULL, &keyPair4); + HcfKeyPair *keyPair4 = nullptr; + res = generator4->generateKeyPair(generator4, nullptr, &keyPair4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair4, nullptr); - ecc512KeyPair_ = keyPair4; + ecc521KeyPair_ = keyPair4; - OH_HCF_OBJ_DESTROY(generator4); + HcfObjDestroy(generator4); } void CryptoEccSignTest::TearDownTestCase() { - OH_HCF_OBJ_DESTROY(ecc224KeyPair_); - OH_HCF_OBJ_DESTROY(ecc256KeyPair_); - OH_HCF_OBJ_DESTROY(ecc384KeyPair_); - OH_HCF_OBJ_DESTROY(ecc512KeyPair_); + HcfObjDestroy(ecc224KeyPair_); + HcfObjDestroy(ecc256KeyPair_); + HcfObjDestroy(ecc384KeyPair_); + HcfObjDestroy(ecc521KeyPair_); } static const char *GetMockClass(void) @@ -127,233 +130,233 @@ static const char *GetMockClass(void) static HcfObjectBase obj = { .getClass = GetMockClass, - .destroy = NULL + .destroy = nullptr }; HWTEST_F(CryptoEccSignTest, CryptoEccSignTest001, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest002, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest003, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest004, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest005, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest006, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest007, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest008, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest009, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest010, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest011, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest012, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest013, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest014, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest015, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest016, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest017, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest018, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest019, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest020, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest021, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate(NULL, &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate(nullptr, &sign); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(sign, nullptr); @@ -361,7 +364,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest021, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest022, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD" "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &sign); @@ -371,7 +374,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest022, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest023, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC257|SHA256", &sign); ASSERT_NE(res, HCF_SUCCESS); @@ -380,7 +383,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest023, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest024, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA257", &sign); ASSERT_NE(res, HCF_SUCCESS); @@ -389,7 +392,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest024, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest025, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|MD5", &sign); ASSERT_NE(res, HCF_SUCCESS); @@ -398,7 +401,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest025, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest026, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256SHA256", &sign); ASSERT_NE(res, HCF_SUCCESS); @@ -407,14 +410,14 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest026, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest027, TestSize.Level0) { - int32_t res = HcfSignCreate("ECC256|SHA256", NULL); + int32_t res = HcfSignCreate("ECC256|SHA256", nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest101, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); @@ -424,12 +427,12 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest101, TestSize.Level0) ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest102, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); @@ -440,20 +443,20 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest102, TestSize.Level0) HWTEST_F(CryptoEccSignTest, CryptoEccSignTest103, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - sign->base.destroy(NULL); + sign->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest104, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); @@ -461,12 +464,12 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest104, TestSize.Level0) sign->base.destroy(&obj); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest105, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); @@ -476,27 +479,27 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest105, TestSize.Level0) ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest106, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - const char *algName = sign->getAlgoName(NULL); + const char *algName = sign->getAlgoName(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest107, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); @@ -506,2135 +509,2169 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest107, TestSize.Level0) ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest201, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest202, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest203, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest204, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest205, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest206, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest207, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest208, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest209, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest210, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest211, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest212, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest213, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest214, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest215, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest216, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest217, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest218, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest219, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest220, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest221, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(NULL, NULL, ecc256KeyPair_->priKey); + res = sign->init(nullptr, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest222, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init((HcfSign *)(&obj), NULL, ecc256KeyPair_->priKey); + res = sign->init((HcfSign *)(&obj), nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest223, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, NULL); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest224, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, (HcfPriKey *)(&obj)); + res = sign->init(sign, nullptr, nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest225, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC256|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, (HcfPriKey *)(&obj)); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest301, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest302, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest303, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest304, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest305, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest306, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest307, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest308, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest309, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest310, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest311, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest312, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest313, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest314, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest315, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest316, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest317, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest318, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest319, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest320, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest321, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(NULL, &mockInput); + res = sign->update(nullptr, &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest322, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update((HcfSign *)(&obj), &mockInput); + res = sign->update((HcfSign *)(&obj), &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC256|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->update(sign, &g_mockInput); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0) +{ + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, NULL); + res = sign->update(sign, nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } -HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0) +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = NULL, + .data = nullptr, .len = 1 }; res = sign->update(sign, &input); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } -HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0) +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest326, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; res = sign->update(sign, &input); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest401, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest402, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest403, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest404, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest405, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest406, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest407, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest408, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest409, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest410, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest411, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest412, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest413, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest414, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest415, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest416, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest417, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest418, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest419, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest420, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest421, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest422, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest423, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest424, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest425, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest426, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest427, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest428, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest429, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest430, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest431, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest432, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest433, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest434, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest435, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest436, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest437, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest438, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest439, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest440, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest441, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(NULL, NULL, &out); + res = sign->sign(nullptr, nullptr, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest442, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign((HcfSign *)(&obj), NULL, &out); + res = sign->sign((HcfSign *)(&obj), nullptr, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest443, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest444, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = NULL, + .data = nullptr, .len = 1 }; HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = sign->sign(sign, &input, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest445, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = sign->sign(sign, &input, &out); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest446, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->sign(sign, NULL, NULL); + res = sign->sign(sign, nullptr, nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest447, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -2648,10 +2685,10 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest447, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2662,46 +2699,46 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest447, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out2 = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out2); + res = sign->sign(sign, nullptr, &out2); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - verify->init(verify, NULL, ecc256KeyPair_->pubKey); + verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); verify->update(verify, &input); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); verify->update(verify, &input); ASSERT_EQ(res, HCF_SUCCESS); - flag = verify->verify(verify, NULL, &out2); + flag = verify->verify(verify, nullptr, &out2); ASSERT_EQ(flag, true); free(out.data); free(out2.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest448, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -2719,30 +2756,30 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest448, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out2 = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out2); + res = sign->sign(sign, nullptr, &out2); free(out2.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest927, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); @@ -2758,7 +2795,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest927, TestSize.Level0) }; HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; res = sign->sign(sign, &input, &out); @@ -2767,24 +2804,24 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest927, TestSize.Level0) ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoEccSignTest, CryptoEccSignTest928, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); @@ -2802,15 +2839,433 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest928, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); free(out.data); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1001, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1002, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1003, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_NOPADDING, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1004, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1005, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1006, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate(nullptr, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1007, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1008, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineUpdate(spiObj, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1009, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1010, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1011, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC224|SHA256", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyPair); + continue; + } + res = sign->init(sign, nullptr, keyPair->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + res = sign->update(sign, input); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, nullptr, &out); + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + if (res == HCF_SUCCESS) { + free(out.data); + } + } +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1101, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfObjDestroy(generator); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC224|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfParamsSpec params; + res = sign->init(sign, ¶ms, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = sign->update(sign, &input); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, nullptr, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(sign); + + uint32_t mallocCount = GetMallocNum(); + MemoryMallocTestFunc(mallocCount, &input); + + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC224|SHA256", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyPair); + continue; + } + res = sign->init(sign, nullptr, keyPair->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + res = sign->update(sign, input); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, input, &out); + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + if (res == HCF_SUCCESS) { + free(out.data); + } + } +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1102, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfObjDestroy(generator); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC224|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfParamsSpec params; + res = sign->init(sign, ¶ms, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = sign->update(sign, &input); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, &input, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(sign); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount, &input); + + EndRecordOpensslCallNum(); } } diff --git a/test/unittest/src/crypto_ecc_verify_test.cpp b/test/unittest/src/crypto_ecc_verify_test.cpp index e466875d837cd68157c676c56359cd1f46d7994f..de53a21ab0ec3363a23c682d1da2d501e8a1d4a6 100644 --- a/test/unittest/src/crypto_ecc_verify_test.cpp +++ b/test/unittest/src/crypto_ecc_verify_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Huawei Device Co., Ltd. + * Copyright (C) 2022-2023 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 @@ -18,9 +18,12 @@ #include "asy_key_generator.h" #include "blob.h" +#include "ecdsa_openssl.h" #include "memory.h" #include "securec.h" #include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" using namespace std; using namespace testing::ext; @@ -36,17 +39,17 @@ public: static HcfKeyPair *ecc224KeyPair_; static HcfKeyPair *ecc256KeyPair_; static HcfKeyPair *ecc384KeyPair_; - static HcfKeyPair *ecc512KeyPair_; + static HcfKeyPair *ecc521KeyPair_; }; HcfKeyPair *CryptoEccVerifyTest::ecc224KeyPair_ = nullptr; HcfKeyPair *CryptoEccVerifyTest::ecc256KeyPair_ = nullptr; HcfKeyPair *CryptoEccVerifyTest::ecc384KeyPair_ = nullptr; -HcfKeyPair *CryptoEccVerifyTest::ecc512KeyPair_ = nullptr; +HcfKeyPair *CryptoEccVerifyTest::ecc521KeyPair_ = nullptr; -static const char *g_mockMessage = "hello world"; -static HcfBlob mockInput = { - .data = (uint8_t *)g_mockMessage, +static const char *MOCK_MESSAGE = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)MOCK_MESSAGE, .len = 12 }; @@ -55,69 +58,69 @@ void CryptoEccVerifyTest::TearDown() {} void CryptoEccVerifyTest::SetUpTestCase() { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); ecc224KeyPair_ = keyPair; - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); - HcfAsyKeyGenerator *generator2 = NULL; + HcfAsyKeyGenerator *generator2 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC256", &generator2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator2, nullptr); - HcfKeyPair *keyPair2 = NULL; - res = generator2->generateKeyPair(generator2, NULL, &keyPair2); + HcfKeyPair *keyPair2 = nullptr; + res = generator2->generateKeyPair(generator2, nullptr, &keyPair2); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair2, nullptr); ecc256KeyPair_ = keyPair2; - OH_HCF_OBJ_DESTROY(generator2); + HcfObjDestroy(generator2); - HcfAsyKeyGenerator *generator3 = NULL; + HcfAsyKeyGenerator *generator3 = nullptr; res = HcfAsyKeyGeneratorCreate("ECC384", &generator3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator3, nullptr); - HcfKeyPair *keyPair3 = NULL; - res = generator3->generateKeyPair(generator3, NULL, &keyPair3); + HcfKeyPair *keyPair3 = nullptr; + res = generator3->generateKeyPair(generator3, nullptr, &keyPair3); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair3, nullptr); ecc384KeyPair_ = keyPair3; - OH_HCF_OBJ_DESTROY(generator3); + HcfObjDestroy(generator3); - HcfAsyKeyGenerator *generator4 = NULL; - res = HcfAsyKeyGeneratorCreate("ECC512", &generator4); + HcfAsyKeyGenerator *generator4 = nullptr; + res = HcfAsyKeyGeneratorCreate("ECC521", &generator4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator4, nullptr); - HcfKeyPair *keyPair4 = NULL; - res = generator4->generateKeyPair(generator4, NULL, &keyPair4); + HcfKeyPair *keyPair4 = nullptr; + res = generator4->generateKeyPair(generator4, nullptr, &keyPair4); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair4, nullptr); - ecc512KeyPair_ = keyPair4; + ecc521KeyPair_ = keyPair4; - OH_HCF_OBJ_DESTROY(generator4); + HcfObjDestroy(generator4); } void CryptoEccVerifyTest::TearDownTestCase() { - OH_HCF_OBJ_DESTROY(ecc224KeyPair_); - OH_HCF_OBJ_DESTROY(ecc256KeyPair_); - OH_HCF_OBJ_DESTROY(ecc384KeyPair_); - OH_HCF_OBJ_DESTROY(ecc512KeyPair_); + HcfObjDestroy(ecc224KeyPair_); + HcfObjDestroy(ecc256KeyPair_); + HcfObjDestroy(ecc384KeyPair_); + HcfObjDestroy(ecc521KeyPair_); } static const char *GetMockClass(void) @@ -127,233 +130,233 @@ static const char *GetMockClass(void) static HcfObjectBase obj = { .getClass = GetMockClass, - .destroy = NULL + .destroy = nullptr }; HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest001, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest002, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest003, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest004, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest005, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest006, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest007, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest008, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest009, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest010, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest011, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest012, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest013, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest014, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest015, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest016, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA1", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest017, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA224", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest018, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA256", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest019, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA384", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest020, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA512", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest021, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate(NULL, &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate(nullptr, &verify); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(verify, nullptr); @@ -361,7 +364,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest021, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest022, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD" "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &verify); @@ -371,7 +374,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest022, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest023, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC257|SHA256", &verify); ASSERT_NE(res, HCF_SUCCESS); @@ -380,7 +383,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest023, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest024, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA257", &verify); ASSERT_NE(res, HCF_SUCCESS); @@ -389,7 +392,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest024, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest025, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|MD5", &verify); ASSERT_NE(res, HCF_SUCCESS); @@ -398,7 +401,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest025, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest026, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256SHA256", &verify); ASSERT_NE(res, HCF_SUCCESS); @@ -407,14 +410,14 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest026, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest027, TestSize.Level0) { - int32_t res = HcfVerifyCreate("ECC256|SHA256", NULL); + int32_t res = HcfVerifyCreate("ECC256|SHA256", nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest101, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); @@ -424,12 +427,12 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest101, TestSize.Level0) ASSERT_NE(className, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest102, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); @@ -440,20 +443,20 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest102, TestSize.Level0) HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest103, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - verify->base.destroy(NULL); + verify->base.destroy(nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest104, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); @@ -461,12 +464,12 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest104, TestSize.Level0) verify->base.destroy(&obj); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest105, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); @@ -476,27 +479,27 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest105, TestSize.Level0) ASSERT_NE(algName, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest106, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - const char *algName = verify->getAlgoName(NULL); + const char *algName = verify->getAlgoName(nullptr); ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest107, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); @@ -506,2833 +509,2867 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest107, TestSize.Level0) ASSERT_EQ(algName, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest201, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest202, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest203, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest204, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest205, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest206, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest207, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest208, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest209, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest210, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest211, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest212, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest213, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest214, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest215, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest216, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA1", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest217, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA224", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest218, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA256", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest219, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA384", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest220, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA512", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest221, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(NULL, NULL, ecc256KeyPair_->pubKey); + res = verify->init(nullptr, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest222, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init((HcfVerify *)(&obj), NULL, ecc256KeyPair_->pubKey); + res = verify->init((HcfVerify *)(&obj), nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest223, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, NULL); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest224, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest225, TestSize.Level0) +{ + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, (HcfPubKey *)(&obj)); + res = verify->init(verify, nullptr, (HcfPubKey *)(&obj)); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest301, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest302, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest303, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest304, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest305, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest306, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest307, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest308, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest309, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest310, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest311, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest312, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest313, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest314, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest315, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest316, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA1", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest317, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA224", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest318, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA256", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest319, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA384", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest320, TestSize.Level0) { - HcfVerify *verify = NULL; - int32_t res = HcfVerifyCreate("ECC512|SHA512", &verify); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest321, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(NULL, &mockInput); + res = verify->update(nullptr, &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest322, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update((HcfVerify *)(&obj), &mockInput); + res = verify->update((HcfVerify *)(&obj), &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest323, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0) +{ + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, NULL); + res = verify->update(verify, nullptr); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } -HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0) +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = NULL, + .data = nullptr, .len = 1 }; res = verify->update(verify, &input); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } -HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0) +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest326, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; res = verify->update(verify, &input); ASSERT_EQ(res, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest401, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest402, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest403, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest404, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest405, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest406, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest407, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest408, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest409, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest410, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest414, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest415, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest416, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA1", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest417, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA224", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest418, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA256", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest419, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA384", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest420, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA512", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest421, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest422, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest423, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest424, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest425, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC224|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc224KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc224KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC224|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest426, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest427, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest428, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest429, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest430, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest431, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest432, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest433, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest434, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest435, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC384|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc384KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc384KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC384|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc384KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest436, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA1", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA1", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA1", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA1", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest437, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA224", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA224", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA224", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA224", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest438, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA256", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA256", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest439, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA384", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA384", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA384", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA384", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest440, TestSize.Level0) { - HcfSign *sign = NULL; - int32_t res = HcfSignCreate("ECC512|SHA512", &sign); + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC521|SHA512", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc512KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc521KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; - res = HcfVerifyCreate("ECC512|SHA512", &verify); + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC521|SHA512", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc512KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest441, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(NULL, NULL, &out); + bool flag = verify->verify(nullptr, nullptr, &out); ASSERT_EQ(flag, false); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest442, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify((HcfVerify *)(&obj), NULL, &out); + bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out); ASSERT_EQ(flag, false); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest443, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, &out); + bool flag = verify->verify(verify, nullptr, &out); ASSERT_EQ(flag, false); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest444, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = NULL, + .data = nullptr, .len = 1 }; bool flag = verify->verify(verify, &input, &out); @@ -3340,48 +3377,48 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest444, TestSize.Level0) ASSERT_EQ(flag, false); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest445, TestSize.Level0) { - HcfSign *sign = NULL; + HcfSign *sign = nullptr; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + res = sign->init(sign, nullptr, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob out = { - .data = NULL, + .data = nullptr, .len = 0 }; - res = sign->sign(sign, NULL, &out); + res = sign->sign(sign, nullptr, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); ASSERT_NE(out.len, (const unsigned int)0); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; bool flag = verify->verify(verify, &input, &out); @@ -3389,84 +3426,472 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest445, TestSize.Level0) ASSERT_EQ(flag, false); free(out.data); - OH_HCF_OBJ_DESTROY(sign); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(sign); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest446, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, NULL, NULL); + bool flag = verify->verify(verify, nullptr, nullptr); ASSERT_EQ(flag, false); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest447, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob mockOut = { - .data = NULL, + .data = nullptr, .len = 1 }; - bool flag = verify->verify(verify, NULL, &mockOut); + bool flag = verify->verify(verify, nullptr, &mockOut); ASSERT_EQ(flag, false); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest448, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob mockOut = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; - bool flag = verify->verify(verify, NULL, &mockOut); + bool flag = verify->verify(verify, nullptr, &mockOut); ASSERT_EQ(flag, false); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest501, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest502, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest503, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_NOPADDING, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest504, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, ecc256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest505, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit(spiObj, nullptr, (HcfPubKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest506, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate(nullptr, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest507, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate((HcfVerifySpi *)&obj, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest508, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineUpdate(spiObj, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest509, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + bool isOk = spiObj->engineVerify(nullptr, &input, &out); + ASSERT_EQ(isOk, false); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest510, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + bool isOk = spiObj->engineVerify((HcfVerifySpi *)&obj, &input, &input); + ASSERT_EQ(isOk, false); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest511, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest512, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +static bool GetSignTestData(HcfBlob *out) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC224|SHA224", &sign); + if (res != HCF_SUCCESS) { + return false; + } + res = sign->init(sign, nullptr, CryptoEccVerifyTest::ecc224KeyPair_->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + return false; + } + res = sign->update(sign, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + return false; + } + res = sign->sign(sign, &g_mockInput, out); + HcfObjDestroy(sign); + return res == HCF_SUCCESS; +} + +static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out) +{ + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, nullptr, CryptoEccVerifyTest::ecc224KeyPair_->pubKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + res = verify->update(verify, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + (void)verify->verify(verify, nullptr, out); + HcfObjDestroy(verify); + } +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest601, TestSize.Level0) +{ + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + GetSignTestData(&out); + StartRecordMallocNum(); + + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetMallocNum(); + MemoryMockTestFunc(mallocCount, &out); + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out) +{ + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, nullptr, CryptoEccVerifyTest::ecc224KeyPair_->pubKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + res = verify->update(verify, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + (void)verify->verify(verify, &g_mockInput, out); + HcfObjDestroy(verify); + } +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest602, TestSize.Level0) +{ + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + ASSERT_EQ(GetSignTestData(&out), true); + StartRecordOpensslCallNum(); + + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount, &out); + EndRecordOpensslCallNum(); } } diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index 813d6f35df9117386c29f8af3f2f1b7e4ed2c850..3ef694e1705df573db720461b764a15c8d5fba38 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -19,6 +19,7 @@ #include "mac.h" #include "sym_key_generator.h" +#include "mac_openssl.h" #include "log.h" #include "memory.h" @@ -35,6 +36,14 @@ public: void TearDown(); }; +constexpr uint32_t MAX_MAC_BLOB_LEN = 5000; +constexpr uint32_t INVALID_LEN = 0; +constexpr uint32_t SHA1_LEN = 20; +constexpr uint32_t SHA224_LEN = 28; +constexpr uint32_t SHA256_LEN = 32; +constexpr uint32_t SHA384_LEN = 48; +constexpr uint32_t SHA512_LEN = 64; + static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n" "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n" "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n" @@ -48,7 +57,6 @@ static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhj "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n" "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n" "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n"; -constexpr uint32_t MAX_MAC_BLOB_LEN = 5000; void CryptoMacTest::SetUpTestCase() {} void CryptoMacTest::TearDownTestCase() {} @@ -71,543 +79,608 @@ static void PrintfBlobInHex(uint8_t *data, size_t dataLen) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacCreateTest002, TestSize.Level0) { - int32_t ret = 0; - ret = (int32_t)HcfMacCreate("SHA1", nullptr); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); - OH_HCF_OBJ_DESTROY(macObj); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA3", &macObj); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMacCreate("SHA3", &macObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate(nullptr, &macObj); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMacCreate(nullptr, &macObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); // test api functions const char *algoName = macObj->getAlgoName(macObj); - ret = strcmp(algoName, "SHA1"); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); + int32_t cmpRes = strcmp(algoName, "SHA1"); + EXPECT_EQ(cmpRes, HCF_SUCCESS); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set a nullptr key HcfSymKey *key = nullptr; // test api functions ret = macObj->init(macObj, key); - EXPECT_NE(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions ret = macObj->update(macObj, &inBlob); - EXPECT_NE(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // define input and output data in blob form - HcfBlob *inBlob= nullptr; + HcfBlob *inBlob = nullptr; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, inBlob); - EXPECT_NE(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + EXPECT_EQ(ret, HCF_SUCCESS); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = macObj->doFinal(macObj, &outBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data - OH_HCF_OBJ_DESTROY(macObj); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); printf("get symkey finish"); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); printf("test init finish"); - ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); printf("test dofinal finish"); PrintfBlobInHex(outBlob.data, outBlob.len); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); printf("HcfBlobDataClearAndFree finish"); - OH_HCF_OBJ_DESTROY(macObj); - printf("OH_HCF_OBJ_DESTROY macObj finish"); - OH_HCF_OBJ_DESTROY(key); - printf("OH_HCF_OBJ_DESTROY key finish"); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + printf("HcfObjDestroy macObj finish"); + HcfObjDestroy(key); + printf("HcfObjDestroy key finish"); + HcfObjDestroy(generator); printf("test finish"); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA256", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); - // set input and output buf - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {0}; + inBlob.data = reinterpret_cast(g_testBigData); + inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN); + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // test api functions - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(macObj); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, INVALID_LEN); + HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 20); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA1_LEN); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA1_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA224", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA224", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[28] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 28); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA224_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA256", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[32] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 32); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA256_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA384", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA384", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[48] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 48); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA384_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA512", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA512", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[64] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, key); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 64); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, SHA512_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(macObj); - OH_HCF_OBJ_DESTROY(key); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); +} + +static const char *GetInvalidMacClass(void) +{ + return "INVALID_MAC_CLASS"; +} + +HWTEST_F(CryptoMacTest, InvalidInputMacTest001, TestSize.Level0) +{ + HcfResult ret = OpensslMacSpiCreate("SHA256", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfMacSpi *spiObj = nullptr; + ret = OpensslMacSpiCreate(nullptr, &spiObj); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoMacTest, NullParamMacTest001, TestSize.Level0) +{ + HcfMac *macObj = nullptr; + HcfResult ret = HcfMacCreate("SHA256", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ret = macObj->init(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = macObj->update(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = macObj->doFinal(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(nullptr); + EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN); + const char *algoName = macObj->getAlgoName(nullptr); + EXPECT_EQ(algoName, nullptr); + macObj->base.destroy(nullptr); + HcfObjDestroy(macObj); +} + +HWTEST_F(CryptoMacTest, InvalidFrameworkClassMacTest001, TestSize.Level0) +{ + HcfMac *macObj = nullptr; + HcfResult ret = HcfMacCreate("SHA256", &macObj); + ASSERT_EQ(ret, HCF_SUCCESS); + HcfMac invalidMacObj = {{0}}; + invalidMacObj.base.getClass = GetInvalidMacClass; + HcfSymKeyGenerator *generator = nullptr; + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); + uint8_t testKey[] = "abcdefghijklmnop"; + uint32_t testKeyLen = sizeof(testKey) / sizeof(testKey[0]); + HcfSymKey *key = nullptr; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; + generator->convertSymKey(generator, &keyMaterialBlob, &key); + uint8_t testData[] = "My test data"; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + ret = macObj->init(&invalidMacObj, key); + EXPECT_NE(ret, HCF_SUCCESS); + ret = macObj->update(&invalidMacObj, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = macObj->doFinal(&invalidMacObj, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(&invalidMacObj); + EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN); + const char *algoName = macObj->getAlgoName(&invalidMacObj); + EXPECT_EQ(algoName, nullptr); + HcfBlobDataClearAndFree(&outBlob); + macObj->base.destroy(&(invalidMacObj.base)); + HcfObjDestroy(macObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) +{ + HcfMacSpi *spiObj = nullptr; + HcfMacSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidMacClass; + // create a symKey generator + HcfSymKeyGenerator *generator = nullptr; + HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, HCF_SUCCESS); + // set key data and convert it to key obj + uint8_t testKey[] = "abcdefghijklmnop"; + uint32_t testKeyLen = 16; + HcfSymKey *key = nullptr; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; + generator->convertSymKey(generator, &keyMaterialBlob, &key); + // set input and output blob + uint8_t testData[] = "My test data"; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + ret = OpensslMacSpiCreate("SHA256", &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + ret = spiObj->engineInitMac(&invalidSpi, key); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = spiObj->engineGetMacLength(&invalidSpi); + EXPECT_EQ(len, INVALID_LEN); + HcfObjDestroy(spiObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); } } \ No newline at end of file diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index 720b218e3792e347b0f25abe1dd5de9e4e35cbbc..e1b0a9e15dbf74c06e3493991fddcb12740091f3 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -17,6 +17,7 @@ #include "securec.h" #include "md.h" +#include "md_openssl.h" #include "log.h" #include "memory.h" @@ -33,6 +34,15 @@ public: void TearDown(); }; +constexpr uint32_t MAX_MD_BLOB_LEN = 5000; +constexpr uint32_t INVALID_LEN = 0; +constexpr uint32_t SHA1_LEN = 20; +constexpr uint32_t SHA224_LEN = 28; +constexpr uint32_t SHA256_LEN = 32; +constexpr uint32_t SHA384_LEN = 48; +constexpr uint32_t SHA512_LEN = 64; +constexpr uint32_t MD5_LEN = 16; + static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n" "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n" "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n" @@ -46,7 +56,6 @@ static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhj "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n" "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n" "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n"; -constexpr uint32_t MAX_MD_BLOB_LEN = 5000; void CryptoMdTest::SetUpTestCase() {} void CryptoMdTest::TearDownTestCase() {} @@ -75,340 +84,362 @@ static void PrintfBlobInHex(uint8_t *data, size_t dataLen) */ HWTEST_F(CryptoMdTest, CryptoFrameworkMdCreateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj - ret = (int32_t)HcfMdCreate("SHA1", nullptr); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); - EXPECT_NE(mdObj, nullptr); - OH_HCF_OBJ_DESTROY(mdObj); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ASSERT_NE(mdObj, nullptr); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA3 obj (not supported) HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA3", &mdObj); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMdCreate("SHA3", &mdObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(mdObj, nullptr); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest003, TestSize.Level0) { - int32_t ret = 0; // create an obj with null algoInput (not supported) HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate(nullptr, &mdObj); - EXPECT_NE(ret, 0); + HcfResult ret = HcfMdCreate(nullptr, &mdObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(mdObj, nullptr); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoNameTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); - EXPECT_NE(mdObj, nullptr); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ASSERT_NE(mdObj, nullptr); // test api functions const char *algoName = mdObj->getAlgoName(mdObj); - ret = strcmp(algoName, "SHA1"); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(mdObj); + int32_t cmpRes = strcmp(algoName, "SHA1"); + EXPECT_EQ(cmpRes, HCF_SUCCESS); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form - HcfBlob *inBlob= nullptr; + HcfBlob *inBlob = nullptr; // test api functions ret = mdObj->update(mdObj, inBlob); - EXPECT_NE(ret, 0); - OH_HCF_OBJ_DESTROY(mdObj); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); - OH_HCF_OBJ_DESTROY(mdObj); + EXPECT_EQ(ret, HCF_SUCCESS); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA256", &mdObj); - EXPECT_EQ(ret, 0); - // set input and output buf - uint8_t outBuf[20] = {0}; + HcfResult ret = HcfMdCreate("SHA256", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = { .data = nullptr, .len = 0 }; + inBlob.data = reinterpret_cast(g_testBigData); + inBlob.len = strnlen(g_testBigData, MAX_MD_BLOB_LEN); + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdLenTest001, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // test api functions - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 20); - OH_HCF_OBJ_DESTROY(mdObj); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA1_LEN); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA1_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA224", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA224", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[28] = {0}; - // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 28); - + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA224_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA256", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA256", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[32] = {0}; - // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 32); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA256_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA384", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA384", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[48] = {0}; - // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 48); - + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA384_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA512", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA512", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[64] = {0}; - // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 64); - + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA512_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("MD5", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("MD5", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; - uint8_t outBuf[16] = {0}; - // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; - + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 16); - + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, MD5_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); - OH_HCF_OBJ_DESTROY(mdObj); + HcfObjDestroy(mdObj); +} + +static const char *GetInvalidMdClass(void) +{ + return "INVALID_MD_CLASS"; +} + +HWTEST_F(CryptoMdTest, InvalidInputMdTest001, TestSize.Level0) +{ + HcfResult ret = OpensslMdSpiCreate("SHA256", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoMdTest, NullParamMdTest001, TestSize.Level0) +{ + HcfMd *mdObj = nullptr; + HcfResult ret = HcfMdCreate("MD5", &mdObj); + ret = mdObj->update(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = mdObj->doFinal(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(nullptr); + EXPECT_EQ(len, HCF_OPENSSL_INVALID_MD_LEN); + const char *algoName = mdObj->getAlgoName(nullptr); + EXPECT_EQ(algoName, nullptr); + mdObj->base.destroy(nullptr); + HcfObjDestroy(mdObj); +} + +HWTEST_F(CryptoMdTest, InvalidFrameworkClassMdTest001, TestSize.Level0) +{ + HcfMd *mdObj = nullptr; + HcfResult ret = HcfMdCreate("SHA256", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); + HcfMd invalidMdObj = {{0}}; + invalidMdObj.base.getClass = GetInvalidMdClass; + uint8_t testData[] = "My test data"; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + ret = mdObj->update(&invalidMdObj, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = mdObj->doFinal(&invalidMdObj, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = mdObj->getMdLength(&invalidMdObj); + EXPECT_EQ(len, HCF_OPENSSL_INVALID_MD_LEN); + const char *algoName = mdObj->getAlgoName(&invalidMdObj); + EXPECT_EQ(algoName, nullptr); + HcfBlobDataClearAndFree(&outBlob); + mdObj->base.destroy(&(invalidMdObj.base)); + HcfObjDestroy(mdObj); +} + +HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) +{ + HcfMdSpi *spiObj = nullptr; + HcfMdSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidMdClass; + // set input and output blob + uint8_t testData[] = "My test data"; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + ret = spiObj->engineUpdateMd(&invalidSpi, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineDoFinalMd(&invalidSpi, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = spiObj->engineGetMdLength(&invalidSpi); + EXPECT_EQ(len, INVALID_LEN); + HcfObjDestroy(spiObj); } } \ No newline at end of file diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index 314062917689935c0b6495b874dafbcd10c8a8ea..09a1546b7d53ef7024ac32c52e2f022c832f9da8 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -17,6 +17,7 @@ #include "securec.h" #include "rand.h" +#include "rand_openssl.h" #include "log.h" #include "memory.h" @@ -52,147 +53,188 @@ void CryptoRandTest::TearDown() // add destroy here, this will be called when te */ HWTEST_F(CryptoRandTest, CryptoFrameworkRandCreateTest001, TestSize.Level0) { - int32_t ret = 0; - ret = (int32_t)HcfRandCreate(nullptr); - EXPECT_NE(ret, 0); + HcfResult ret = HcfRandCreate(nullptr); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 0; - uint8_t randomBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random with length 0 ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_NE(ret, 0); - OH_HCF_OBJ_DESTROY(randObj); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 32; - uint8_t randomBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&randomBlob); - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 8192; - uint8_t randomBuf[8192] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&randomBlob); - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest004, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 8193; - uint8_t randomBuf[8193] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest001, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // define randomBlob and seedBlob struct HcfBlob *seedBlob = nullptr; // test set seed ret = randObj->setSeed(randObj, seedBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t seedLen = 32; - uint8_t seedBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {.data = (uint8_t *)seedBuf, .len = 0}; + struct HcfBlob seedBlob = { .data = nullptr, .len = 0 }; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // test set seed ret = randObj->setSeed(randObj, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&seedBlob); - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); } HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t seedLen = 1000; - uint8_t seedBuf[1000] = {0}; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {.data = (uint8_t *)seedBuf, .len = 0}; + struct HcfBlob seedBlob = { .data = nullptr, .len = 0 }; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // test set seed ret = randObj->setSeed(randObj, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&seedBlob); - OH_HCF_OBJ_DESTROY(randObj); + HcfObjDestroy(randObj); +} + +static const char *GetInvalidRandClass(void) +{ + return "INVALID_RAND_CLASS"; +} + +HWTEST_F(CryptoRandTest, NullInputRandTest001, TestSize.Level0) +{ + HcfResult ret = HcfRandSpiCreate(nullptr); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoRandTest, NullParamRandTest001, TestSize.Level0) +{ + HcfRand *randObj = nullptr; + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ret = randObj->generateRandom(nullptr, 0, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = randObj->setSeed(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + randObj->base.destroy(nullptr); + HcfObjDestroy(randObj); +} + +HWTEST_F(CryptoRandTest, InvalidFrameworkClassRandTest001, TestSize.Level0) +{ + HcfRand *randObj = nullptr; + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, HCF_SUCCESS); + HcfRand invalidRandObj = {{0}}; + invalidRandObj.base.getClass = GetInvalidRandClass; + int32_t randomLen = 32; + struct HcfBlob randomBlob = { .data = nullptr, .len = 0 }; + ret = randObj->generateRandom(&invalidRandObj, randomLen, &randomBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = randObj->setSeed(&invalidRandObj, &randomBlob); + EXPECT_NE(ret, HCF_SUCCESS); + HcfBlobDataClearAndFree(&randomBlob); + randObj->base.destroy(&(invalidRandObj.base)); + HcfObjDestroy(randObj); +} + +HWTEST_F(CryptoRandTest, InvalidSpiClassRandTest001, TestSize.Level0) +{ + HcfRandSpi *spiObj = nullptr; + HcfRandSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidRandClass; + HcfResult ret = HcfRandSpiCreate(&spiObj); + ASSERT_EQ(ret, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + HcfObjDestroy(spiObj); } } \ No newline at end of file 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 3c9d3c082dad4c4f58898953052d1bc04d0a8de2..75d66d71594d9b2f3b16103211c3207d43c333b4 100644 --- a/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp @@ -40,7 +40,7 @@ void CryptoRsaAsyKeyGeneratorTest::TearDown() {} // HcfAsyKeyGeneratorCreate correct case: no primes HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest100, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -48,12 +48,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest100, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest110, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -61,12 +61,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest110, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest120, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -74,13 +74,13 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest120, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest130, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -88,12 +88,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest130, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest140, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -101,12 +101,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest140, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest150, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -114,13 +114,13 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest150, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } // HcfAsyKeyGeneratorCreate correct case: with primes HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest200, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -128,12 +128,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest200, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest210, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -141,12 +141,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest210, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest220, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -154,12 +154,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest220, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest230, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -167,12 +167,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest230, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest240, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -180,12 +180,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest240, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest250, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -193,12 +193,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest250, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest260, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -206,12 +206,12 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest260, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest270, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_4", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); @@ -219,122 +219,147 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest270, TestSize EXPECT_NE(generator->base.destroy, nullptr); EXPECT_NE(generator->generateKeyPair, nullptr); EXPECT_NE(generator->getAlgoName, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } // HcfAsyKeyGeneratorCreate Incorrect case : algname is null HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest300, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; - HcfResult res = HcfAsyKeyGeneratorCreate(NULL, &generator); + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate(nullptr, &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest301, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("", &generator); + EXPECT_NE(res, HCF_SUCCESS); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest310, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("111111111111111111111111111111111111111111111111111111111111111111111111" "111111111111111111111111111111111111111111111111111111111111111111111", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest320, TestSize.Level0) { - HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", NULL); + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", nullptr); EXPECT_NE(res, HCF_SUCCESS); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest330, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA12315", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest340, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_777", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest350, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_3", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest360, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_3", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest370, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_4", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest380, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_4", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest381, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest390, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_5", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest391, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA8192|PRIMES_5", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest400, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); - generator = NULL; - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); + generator = nullptr; + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest410, TestSize.Level0) { - OH_HCF_OBJ_DESTROY(NULL); + HcfObjDestroy(nullptr); } // generateKeyPair correct case HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest500, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); @@ -356,17 +381,17 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest500, TestSize EXPECT_NE(prikey->base.base.destroy, nullptr); EXPECT_NE(prikey->clearMem, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest510, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); @@ -388,30 +413,72 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest510, TestSize EXPECT_NE(prikey->base.base.destroy, nullptr); EXPECT_NE(prikey->clearMem, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest511, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfBlob pubKeyBlob; + HcfBlob priKeyBlob; + HcfPubKey *pubKey = keyPair->pubKey; + HcfPriKey *priKey = keyPair->priKey; + + res = pubKey->base.getEncoded((HcfKey *)priKey, &pubKeyBlob); + EXPECT_NE(res, HCF_SUCCESS); + res = priKey->base.getEncoded((HcfKey *)pubKey, &priKeyBlob); + EXPECT_NE(res, HCF_SUCCESS); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfFree(pubKeyBlob.data); + HcfFree(priKeyBlob.data); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfPubKey *pubKey = keyPair->pubKey; + HcfPriKey *priKey = keyPair->priKey; + + res = pubKey->base.getEncoded((HcfKey *)priKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + res = priKey->base.getEncoded((HcfKey *)pubKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // generateKeyPair conrrect case: use getEncode encode pubkey and prikey HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -428,28 +495,70 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); +} + +// Test muliti getEncoded and convertKey +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest521, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfBlob pubKeyBlob1 = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob1 = {.data = nullptr, .len = 0}; + res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob1); + EXPECT_EQ(res, HCF_SUCCESS); + res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob1); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *dupKeyPair1 = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob1, &priKeyBlob1, &dupKeyPair1); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *dupKeyPair2 = nullptr; + HcfBlob pubKeyBlob2 = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob2 = {.data = nullptr, .len = 0}; + res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob2); + EXPECT_EQ(res, HCF_SUCCESS); + res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob2); + EXPECT_EQ(res, HCF_SUCCESS); + res = generator->convertKey(generator, nullptr, &pubKeyBlob2, &priKeyBlob2, &dupKeyPair2); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfFree(pubKeyBlob1.data); + HcfFree(priKeyBlob1.data); + HcfFree(pubKeyBlob2.data); + HcfFree(priKeyBlob2.data); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair1); + HcfObjDestroy(dupKeyPair2); } // generateKeyPair correct case: getEncode encode pubkey HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; - HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, NULL, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -458,28 +567,28 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize EXPECT_NE(pubkey->base.base.destroy, nullptr); HcfFree(pubKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } // generateKeyPair correct case: getEncode encode prikey HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, NULL, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = dupKeyPair->priKey; @@ -490,30 +599,30 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize EXPECT_NE(prikey->clearMem, nullptr); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -530,30 +639,30 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -570,30 +679,30 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -610,30 +719,30 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -650,82 +759,82 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } // generateKeyPair incorrect case: user wrong ECC class, ignore in this version HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest600, TestSize.Level0) { - HcfAsyKeyGenerator *eccGenerator = NULL; + HcfAsyKeyGenerator *eccGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(eccGenerator, nullptr); - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - HcfKeyPair *keyPair = NULL; - res = rsaGenerator->generateKeyPair(eccGenerator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = rsaGenerator->generateKeyPair(eccGenerator, nullptr, &keyPair); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(eccGenerator); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(keyPair); + HcfObjDestroy(eccGenerator); + HcfObjDestroy(rsaGenerator); } // generateKeyPair incorrect case: generator class is null HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest610, TestSize.Level0) { - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - HcfKeyPair *keyPair = NULL; - res = rsaGenerator->generateKeyPair(NULL, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = rsaGenerator->generateKeyPair(nullptr, nullptr, &keyPair); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(keyPair, nullptr); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(rsaGenerator); } // generateKeyPair incorrect case: keypair is null HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest620, TestSize.Level0) { - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, NULL); + res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(rsaGenerator); } // convertKey correct case HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = dupKeyPair->pubKey; EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr); @@ -742,108 +851,194 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(dupKeyPair); } // convertKey incorrect case: input ECC class HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest710, TestSize.Level0) { - HcfAsyKeyGenerator *eccGenerator = NULL; + HcfAsyKeyGenerator *eccGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(eccGenerator, nullptr); - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - HcfKeyPair *dupKeyPair = NULL; - res = rsaGenerator->convertKey(eccGenerator, NULL, NULL, NULL, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = rsaGenerator->convertKey(eccGenerator, nullptr, nullptr, nullptr, &dupKeyPair); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(dupKeyPair, nullptr); - OH_HCF_OBJ_DESTROY(eccGenerator); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(eccGenerator); + HcfObjDestroy(rsaGenerator); } // convertKey incorrect case: input null generator HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest720, TestSize.Level0) { - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - HcfKeyPair *keyPair = NULL; - res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = rsaGenerator->convertKey(NULL, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = rsaGenerator->convertKey(nullptr, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(dupKeyPair, nullptr); HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(keyPair); + HcfObjDestroy(rsaGenerator); } // convertKey incorrect case: input null dupkeypair HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest730, TestSize.Level0) { - HcfAsyKeyGenerator *rsaGenerator = NULL; + HcfAsyKeyGenerator *rsaGenerator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(rsaGenerator, nullptr); - HcfKeyPair *keyPair = NULL; - res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = rsaGenerator->convertKey(rsaGenerator, NULL, &pubKeyBlob, &priKeyBlob, NULL); + HcfKeyPair *dupKeyPair = nullptr; + res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, nullptr); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(dupKeyPair, nullptr); HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(rsaGenerator); + HcfObjDestroy(keyPair); + HcfObjDestroy(rsaGenerator); } // Incorrect case: use wrong bits or primes HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest800, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1111", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest810, TestSize.Level0) { - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(generator, nullptr); + HcfObjDestroy(generator); +} + +// 测试异常释放 +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest820, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(generator, nullptr); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(generator); +} + +// prikey clear mem +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest830, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + keyPair->priKey->clearMem(nullptr); + + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest840, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey); + + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest850, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + keyPair->priKey->clearMem(keyPair->priKey); + + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +// correct case: use destroy function inclass(not HcfObjDestroy) +HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest900, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfPubKey *pubkey = keyPair->pubKey; + HcfPriKey *prikey = keyPair->priKey; + + EXPECT_EQ(pubkey->base.getFormat((HcfKey *)prikey), nullptr); + EXPECT_EQ(prikey->base.getFormat((HcfKey *)pubkey), nullptr); + + EXPECT_EQ(pubkey->base.getFormat(nullptr), nullptr); + EXPECT_EQ(prikey->base.getFormat(nullptr), nullptr); + + EXPECT_EQ(pubkey->base.getAlgorithm((HcfKey *)prikey), nullptr); + EXPECT_EQ(prikey->base.getAlgorithm((HcfKey *)pubkey), nullptr); + + EXPECT_EQ(pubkey->base.getAlgorithm(nullptr), nullptr); + EXPECT_EQ(prikey->base.getAlgorithm(nullptr), nullptr); + + prikey->base.base.destroy(nullptr); + pubkey->base.base.destroy(nullptr); + keyPair->base.destroy(nullptr); + + prikey->base.base.destroy((HcfObjectBase *)pubkey); + pubkey->base.base.destroy((HcfObjectBase *)prikey); + keyPair->base.destroy((HcfObjectBase *)prikey); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} } -} \ No newline at end of file diff --git a/test/unittest/src/crypto_rsa_cipher_test.cpp b/test/unittest/src/crypto_rsa_cipher_test.cpp index 8d679138f36abdbbb311ce957432654b42d34e0c..9260089bbfa25f218927bf4b60131d4891f9c7f7 100644 --- a/test/unittest/src/crypto_rsa_cipher_test.cpp +++ b/test/unittest/src/crypto_rsa_cipher_test.cpp @@ -38,11 +38,29 @@ void CryptoRsaCipherTest::TearDownTestCase() {} void CryptoRsaCipherTest::SetUp() {} void CryptoRsaCipherTest::TearDown() {} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest90, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|NoPadding", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(cipher, nullptr); + EXPECT_NE(cipher->base.getClass(), nullptr); + EXPECT_NE(cipher->base.destroy, nullptr); + EXPECT_NE(cipher->init, nullptr); + EXPECT_NE(cipher->update, nullptr); + EXPECT_NE(cipher->doFinal, nullptr); + EXPECT_NE(cipher->getAlgorithm, nullptr); + HcfObjDestroy(cipher); +} + + // HcfCipherCreate correct case: RSAXXX + padding HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest100, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -51,13 +69,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest100, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest110, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -66,13 +84,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest110, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest120, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -81,13 +99,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest120, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest130, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -96,13 +114,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest130, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest140, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -111,13 +129,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest140, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest150, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA512|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -126,13 +144,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest150, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest160, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -141,13 +159,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest160, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest170, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -156,13 +174,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest170, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest180, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_MD5", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -171,13 +189,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest180, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest190, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA512", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -186,13 +204,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest190, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest200, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA512|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -201,13 +219,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest200, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest210, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA768|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -216,13 +234,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest210, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest220, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -231,13 +249,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest220, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest230, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA512|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -246,13 +264,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest230, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest240, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA768|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -261,13 +279,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest240, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest250, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -276,13 +294,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest250, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest260, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA512|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -291,13 +309,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest260, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest270, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA768|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -306,13 +324,13 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest270, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest280, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); @@ -321,23 +339,22 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest280, TestSize.Level0) EXPECT_NE(cipher->init, nullptr); EXPECT_NE(cipher->update, nullptr); EXPECT_NE(cipher->doFinal, nullptr); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } - // HcfCipherCreate Incorrect case HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest300, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", NULL); + res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", nullptr); EXPECT_NE(res, HCF_SUCCESS); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest310, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; - res = HcfCipherCreate(NULL, &cipher); + HcfCipher *cipher = nullptr; + res = HcfCipherCreate(nullptr, &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); } @@ -345,7 +362,7 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest310, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest320, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256|2111111111111111111111111111111111111111111111" "111111111111123123", &cipher); EXPECT_NE(res, HCF_SUCCESS); @@ -355,7 +372,7 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest320, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest330, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA333", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); @@ -364,7 +381,7 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest330, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest340, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP111|SHA256|MGF1_SHA333", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); @@ -373,7 +390,7 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest340, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest350, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2111048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); @@ -382,168 +399,208 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest350, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest360, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256111|MGF1_SHA256", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); } +// Create Cipher without padding +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest370, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA2048", &cipher); + EXPECT_NE(res, HCF_SUCCESS); +} + +// create Nopadding Cipher with md digest. +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest380, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA2048|NoPadding|SHA256", &cipher); + EXPECT_NE(res, HCF_SUCCESS); +} + + // destroyCipher HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest400, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(cipher, nullptr); - OH_HCF_OBJ_DESTROY(cipher); - cipher = NULL; - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); + cipher = nullptr; + HcfObjDestroy(cipher); } // init correct case HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest500, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest501, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, (enum HcfCryptoMode)123, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest510, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } // init incorrect case HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest600, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest610, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest620, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(NULL, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(nullptr, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } // incorrect case: use diff class, we ignore it in this version HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest630, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *aesCipher = NULL; + HcfCipher *aesCipher = nullptr; res = HcfCipherCreate("AES128|ECB|PKCS7", &aesCipher); EXPECT_EQ(res, HCF_SUCCESS); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(aesCipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(aesCipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); - OH_HCF_OBJ_DESTROY(aesCipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + HcfObjDestroy(aesCipher); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest640, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, NULL, NULL); + res = cipher->init(cipher, DECRYPT_MODE, nullptr, nullptr); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); } // correct case: update not support @@ -551,27 +608,27 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest700, TestSize.Level0) { uint8_t plan[] = "this is rsa cipher test!\0"; HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->update(cipher, &input, &encoutput); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(encoutput.data, nullptr); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } // dofinal correct case @@ -579,132 +636,132 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest800, TestSize.Level0) { HcfResult res = HCF_SUCCESS; uint8_t plan[] = "this is rsa cipher test!\0"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &input, &encoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); - HcfBlob decoutput = {.data = NULL, .len = 0}; - cipher = NULL; + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &encoutput, &decoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); EXPECT_STREQ((char *)plan, (char *)decoutput.data); HcfFree(encoutput.data); HcfFree(decoutput.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest810, TestSize.Level0) { HcfResult res = HCF_SUCCESS; uint8_t plan[] = "this is rsa cipher test!\0"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_3", &generator); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &input, &encoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); - HcfBlob decoutput = {.data = NULL, .len = 0}; - cipher = NULL; + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &encoutput, &decoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); EXPECT_STREQ((char *)plan, (char *)decoutput.data); HcfFree(encoutput.data); HcfFree(decoutput.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest820, TestSize.Level0) { HcfResult res = HCF_SUCCESS; uint8_t plan[] = "this is rsa cipher test!\0"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &input, &encoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); - HcfBlob decoutput = {.data = NULL, .len = 0}; - cipher = NULL; + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &encoutput, &decoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); EXPECT_STREQ((char *)plan, (char *)decoutput.data); HcfFree(encoutput.data); HcfFree(decoutput.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // incorrect case: algName out of boundary @@ -713,44 +770,44 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest830, TestSize.Level0) HcfResult res = HCF_SUCCESS; uint8_t plan[] = "this is rsa cipher test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!\0"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &input, &encoutput); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); - HcfBlob decoutput = {.data = NULL, .len = 0}; - cipher = NULL; + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &encoutput, &decoutput); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); EXPECT_STRNE((char *)plan, (char *)decoutput.data); HcfFree(encoutput.data); HcfFree(decoutput.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } @@ -759,15 +816,15 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest840, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); @@ -778,15 +835,15 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest845, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|MGF1_SHA256", &cipher); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(cipher, nullptr); @@ -796,56 +853,56 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest845, TestSize.Level0) HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest850, TestSize.Level0) { uint8_t plan[] = "this is rsa cipher test!\0"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(generator, nullptr); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob pubKeyBlob = {.data = NULL, .len = 0}; - HcfBlob priKeyBlob = {.data = NULL, .len = 0}; + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob); EXPECT_EQ(res, HCF_SUCCESS); - HcfKeyPair *dupKeyPair = NULL; - res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair); + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(generator); - OH_HCF_OBJ_DESTROY(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; - HcfBlob encoutput = {.data = NULL, .len = 0}; - HcfCipher *cipher = NULL; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)dupKeyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)dupKeyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &input, &encoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); - HcfBlob decoutput = {.data = NULL, .len = 0}; - cipher = NULL; + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)dupKeyPair->priKey, NULL); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)dupKeyPair->priKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); res = cipher->doFinal(cipher, &encoutput, &decoutput); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); EXPECT_STREQ((char *)plan, (char *)decoutput.data); HcfFree(encoutput.data); HcfFree(decoutput.data); HcfFree(pubKeyBlob.data); HcfFree(priKeyBlob.data); - OH_HCF_OBJ_DESTROY(dupKeyPair); + HcfObjDestroy(dupKeyPair); } // correct case: test OAEP Plaintext boundary: @@ -856,26 +913,26 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest860, TestSize.Level0) uint8_t plan1[] = "00112233445566778899aabbccddeeff0aaaaaaaaaaaaaaaaaaaaaaaaaa"; uint8_t plan2[] = "00112233445566778899aabbccddeeffaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; uint8_t plan3[] = "00112233445566778899aabbccddeeff00112233445566778899aaaaaaaaaa"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob encoutput1 = {.data = NULL, .len = 0}; - HcfBlob encoutput2 = {.data = NULL, .len = 0}; - HcfBlob encoutput3 = {.data = NULL, .len = 0}; + HcfBlob encoutput1 = {.data = nullptr, .len = 0}; + HcfBlob encoutput2 = {.data = nullptr, .len = 0}; + HcfBlob encoutput3 = {.data = nullptr, .len = 0}; HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)}; HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)}; HcfBlob input3 = {.data = (uint8_t *)plan3, .len = strlen((char *)plan3)}; @@ -887,12 +944,12 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest860, TestSize.Level0) EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); HcfFree(encoutput1.data); HcfFree(encoutput2.data); HcfFree(encoutput3.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // correct case: test nopadding boundary < RSA_size(rsa) @@ -904,26 +961,26 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest870, TestSize.Level0) uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600" "112233445511111111111611111111111"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|NoPadding", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob encoutput1 = {.data = NULL, .len = 0}; - HcfBlob encoutput2 = {.data = NULL, .len = 0}; + HcfBlob encoutput1 = {.data = nullptr, .len = 0}; + HcfBlob encoutput2 = {.data = nullptr, .len = 0}; HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)}; HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)}; @@ -933,11 +990,11 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest870, TestSize.Level0) res = cipher->doFinal(cipher, &input2, &encoutput2); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); HcfFree(encoutput1.data); HcfFree(encoutput2.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // correct case: test PKCS1 boundary < RSA_size(rsa) - 11 @@ -949,25 +1006,25 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest880, TestSize.Level0) uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600" "11223344551111111111161"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(keyPair, nullptr); EXPECT_NE(keyPair->priKey, nullptr); EXPECT_NE(keyPair->pubKey, nullptr); - HcfCipher *cipher = NULL; + HcfCipher *cipher = nullptr; res = HcfCipherCreate("RSA1024|PKCS1", &cipher); EXPECT_EQ(res, HCF_SUCCESS); - res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); EXPECT_EQ(res, HCF_SUCCESS); - HcfBlob encoutput1 = {.data = NULL, .len = 0}; - HcfBlob encoutput2 = {.data = NULL, .len = 0}; + HcfBlob encoutput1 = {.data = nullptr, .len = 0}; + HcfBlob encoutput2 = {.data = nullptr, .len = 0}; HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)}; HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)}; @@ -977,10 +1034,133 @@ HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest880, TestSize.Level0) res = cipher->doFinal(cipher, &input2, &encoutput2); EXPECT_NE(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(cipher); + HcfObjDestroy(cipher); HcfFree(encoutput1.data); HcfFree(encoutput2.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest890, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + + res = cipher->init((HcfCipher *)generator, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); + HcfObjDestroy(cipher); + HcfObjDestroy(keyPair); +} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest900, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(keyPair, nullptr); + EXPECT_NE(keyPair->priKey, nullptr); + EXPECT_NE(keyPair->pubKey, nullptr); + + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "12312123123"; + HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; + + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + + res = cipher->doFinal(cipher, &input, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest910, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(keyPair, nullptr); + EXPECT_NE(keyPair->priKey, nullptr); + EXPECT_NE(keyPair->pubKey, nullptr); + + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "12312123123"; + HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; + + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfBlob blob; + res = cipher->doFinal((HcfCipher *)generator, &input, &blob); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest920, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA10|PK1", &cipher); + EXPECT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest930, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|" + "RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1", &cipher); + EXPECT_NE(res, HCF_SUCCESS); +} + +// incorrect : init Cipher twice +HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest940, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("RSA1024|PKCS1", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); } +} \ No newline at end of file diff --git a/test/unittest/src/crypto_rsa_sign_test.cpp b/test/unittest/src/crypto_rsa_sign_test.cpp index 652680e4ba46127aea74a25b9a6958546e1162de..aafdbe0622a05b922d253177bcb8c0039eb912d9 100644 --- a/test/unittest/src/crypto_rsa_sign_test.cpp +++ b/test/unittest/src/crypto_rsa_sign_test.cpp @@ -42,7 +42,7 @@ void CryptoRsaSignTest::TearDownTestCase() {} HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest100, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|MD5", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -51,13 +51,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest100, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest110, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA1", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -66,13 +66,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest110, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest120, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -81,13 +81,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest120, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest130, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA512", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -96,13 +96,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest130, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest140, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA1|MGF1_SHA1", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -111,13 +111,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest140, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest150, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -126,13 +126,13 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest150, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest160, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); EXPECT_NE(sign, nullptr); @@ -141,14 +141,14 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest160, TestSize.Level0) EXPECT_NE(sign->init, nullptr); EXPECT_NE(sign->update, nullptr); EXPECT_NE(sign->sign, nullptr); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); } // HcfSignCreate Incorrect case HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest200, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSSaa|SHA256|MGF1_SHA256", &sign); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(sign, nullptr); @@ -157,8 +157,8 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest200, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest210, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; - res = HcfSignCreate(NULL, &sign); + HcfSign *sign = nullptr; + res = HcfSignCreate(nullptr, &sign); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(sign, nullptr); } @@ -166,7 +166,7 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest210, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest220, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256|123123123123123123212312312321" "123123123123213asdasdasdasdasdasdasdasdasdasdasdasdasdsasdasds12", &sign); EXPECT_NE(res, HCF_SUCCESS); @@ -176,7 +176,7 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest220, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest230, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", &sign); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(sign, nullptr); @@ -185,7 +185,7 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest230, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest240, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256asdasdas", &sign); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(sign, nullptr); @@ -194,7 +194,7 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest240, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest250, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", &sign); EXPECT_NE(res, HCF_SUCCESS); EXPECT_EQ(sign, nullptr); @@ -203,308 +203,507 @@ HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest250, TestSize.Level0) HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest260, TestSize.Level0) { HcfResult res = HCF_SUCCESS; - res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", NULL); + res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", nullptr); EXPECT_NE(res, HCF_SUCCESS); } +// incorrect case : init signer with nullptr private key. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest270, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + res = sign->init(sign, nullptr, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +// incorrect case : init signer with public Key. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest280, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfPubKey *pubKey = keyPair->pubKey; + + res = sign->init(sign, nullptr, (HcfPriKey *)pubKey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +// incorrect case : use update function before intialize. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest281, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + res = sign->update(sign, &input); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +// incorrect case : use sign function before intialize. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest290, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + HcfBlob signatureData = {.data = nullptr, .len = 0}; + res = sign->sign(sign, &input, &signatureData); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +// incorrect case : init with other class (not cipher). +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest291, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + res = sign->init((HcfSign *)generator, nullptr, keyPair->priKey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +// incorrect case : update with other class (not cipher). +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest292, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + res = sign->update((HcfSign *)generator, &input); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); +} + +// incorrect case : sign with other class (not cipher). +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest293, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfBlob input; + res = sign->sign((HcfSign *)generator, nullptr, &input); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +// incorrect case : update with nullptr inputBlob. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest294, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +// incorrect case : sign with nullptr outputBlob. +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest295, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); + + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + res = sign->sign(sign, nullptr, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + + // correct case: sign and update HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest300, TestSize.Level0) { + HcfResult res = HCF_SUCCESS; uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; - HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA768|PKCS1|SHA1", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest310, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest320, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA2048|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest330, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest340, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PKCS1|SHA512", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest350, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest360, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA2048|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest370, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA3072|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest380, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest390, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PSS|SHA512|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest400, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PSS|SHA1|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest410, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA4096|PSS|SHA256|MGF1_MD5", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +// incorrect case: double init sign +HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest500, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfPriKey *prikey = keyPair->priKey; + HcfSign *sign = nullptr; + res = HcfSignCreate("RSA4096|PKCS1|SHA512", &sign); + EXPECT_EQ(res, HCF_SUCCESS); + + res = sign->init(sign, nullptr, prikey); + EXPECT_EQ(res, HCF_SUCCESS); + res = sign->init(sign, nullptr, prikey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } } diff --git a/test/unittest/src/crypto_rsa_verify_test.cpp b/test/unittest/src/crypto_rsa_verify_test.cpp index a4f1e3280bf3104659bac779a9eb24abf7172624..7b8c7b29fc30065a91ea1ab7f1b6196114babc2f 100644 --- a/test/unittest/src/crypto_rsa_verify_test.cpp +++ b/test/unittest/src/crypto_rsa_verify_test.cpp @@ -41,171 +41,370 @@ void CryptoRsaVerifyTest::TearDownTestCase() {} HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest100, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("RSA1024|PSS|SHA256", &verify); EXPECT_NE(res, HCF_SUCCESS); ASSERT_EQ(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest110, TestSize.Level0) { - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); } -HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest200, TestSize.Level0) +// incorrect case : init signer with nullptr public key. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest120, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init(verify, nullptr, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +// incorrect case : init signer with private Key. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest130, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init(verify, nullptr, (HcfPubKey *)keyPair->priKey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(verify); +} + +// incorrect case : init with other class (not cipher). +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest140, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init((HcfVerify *)generator, nullptr, keyPair->pubKey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(verify); +} + +// incorrect case : update with other class (not cipher). +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest150, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + res = verify->update((HcfVerify *)generator, &input); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +// incorrect case : verify with other class (not cipher). +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest160, TestSize.Level0) { + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + uint8_t plan[] = "this is rsa verify test."; - HcfAsyKeyGenerator *generator = NULL; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + bool result = verify->verify((HcfVerify *)generator, &input, &input); + EXPECT_NE(result, true); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +// incorrect case : use update function before intialize. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest170, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + res = verify->update(verify, &input); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +// incorrect case : use verify function before intialize. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest180, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + + uint8_t plan[] = "this is rsa verify test."; + HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; + bool result = verify->verify(verify, nullptr, &input); + EXPECT_NE(result, true); + + HcfObjDestroy(verify); +} + +// incorrect case : update with nullptr inputBlob. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest190, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfPubKey *pubkey = keyPair->pubKey; + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init(verify, nullptr, pubkey); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->update(verify, nullptr); + EXPECT_NE(res, 1); + + HcfObjDestroy(verify); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +// incorrect case : verify with nullptr outputBlob. +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest191, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfPubKey *pubkey = keyPair->pubKey; + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init(verify, nullptr, pubkey); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->verify(verify, nullptr, nullptr); + EXPECT_NE(res, 1); + + HcfObjDestroy(verify); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +// incorrect case : init verify twice +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest192, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfPubKey *pubkey = keyPair->pubKey; + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); + EXPECT_EQ(res, HCF_SUCCESS); + + res = verify->init(verify, nullptr, pubkey); + EXPECT_EQ(res, HCF_SUCCESS); + res = verify->init(verify, nullptr, pubkey); + EXPECT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest200, TestSize.Level0) +{ + uint8_t plan[] = "this is rsa verify test."; + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->verify(verify, &input, &verifyData); - EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + bool result = verify->verify(verify, &input, &verifyData); + EXPECT_EQ(result, true); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest210, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest220, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest230, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest240, TestSize.Level0) @@ -213,39 +412,39 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest240, TestSize.Level0) uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; uint8_t errorverify[] = "asdfasdfasdfasf"; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; + HcfBlob verifyData = {.data = nullptr, .len = 0}; HcfBlob invalidverifyData = {.data = errorverify, .len = strlen((char *)errorverify)}; - HcfSign *sign = NULL; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &invalidverifyData); EXPECT_EQ(res, 0); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // Incorrect case: different mode @@ -253,38 +452,38 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest250, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 0); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // Incorrect case: different mgf1md @@ -292,38 +491,38 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest260, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 0); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } @@ -332,38 +531,38 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest270, TestSize.Level0) { uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; HcfPriKey *prikey = keyPair->priKey; HcfBlob input = {.data = plan, .len = strlen((char *)plan)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input, &verifyData); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PKCS1|SHA512", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input, &verifyData); EXPECT_EQ(res, 0); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // check update_func in PSS padding @@ -373,11 +572,11 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest280, TestSize.Level0) "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; @@ -385,32 +584,32 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest280, TestSize.Level0) HcfBlob input = {.data = plan1, .len = strlen((char *)plan1)}; HcfBlob inputEx = {.data = plan2, .len = strlen((char *)plan2)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->update(sign, &input); EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &inputEx, &verifyData); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->update(verify, &input); EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &inputEx, &verifyData); EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // check update in PKCS1 padding @@ -423,11 +622,11 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest290, TestSize.Level0) uint8_t plan3[] = "this is rsa verify test plane3 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; - HcfAsyKeyGenerator *generator = NULL; + HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator); - HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); EXPECT_EQ(res, HCF_SUCCESS); HcfPubKey *pubkey = keyPair->pubKey; @@ -436,11 +635,11 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest290, TestSize.Level0) HcfBlob input1 = {.data = plan1, .len = strlen((char *)plan1)}; HcfBlob input2 = {.data = plan2, .len = strlen((char *)plan2)}; HcfBlob input3 = {.data = plan3, .len = strlen((char *)plan3)}; - HcfBlob verifyData = {.data = NULL, .len = 0}; - HcfSign *sign = NULL; + HcfBlob verifyData = {.data = nullptr, .len = 0}; + HcfSign *sign = nullptr; res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign); EXPECT_EQ(res, HCF_SUCCESS); - res = sign->init(sign, NULL, prikey); + res = sign->init(sign, nullptr, prikey); EXPECT_EQ(res, HCF_SUCCESS); res = sign->update(sign, &input1); EXPECT_EQ(res, HCF_SUCCESS); @@ -448,12 +647,12 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest290, TestSize.Level0) EXPECT_EQ(res, HCF_SUCCESS); res = sign->sign(sign, &input3, &verifyData); EXPECT_EQ(res, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(sign); + HcfObjDestroy(sign); - HcfVerify *verify = NULL; + HcfVerify *verify = nullptr; res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify); EXPECT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, NULL, pubkey); + res = verify->init(verify, nullptr, pubkey); EXPECT_EQ(res, HCF_SUCCESS); res = verify->update(verify, &input1); EXPECT_EQ(res, HCF_SUCCESS); @@ -461,10 +660,10 @@ HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest290, TestSize.Level0) EXPECT_EQ(res, HCF_SUCCESS); res = verify->verify(verify, &input3, &verifyData); EXPECT_EQ(res, 1); - OH_HCF_OBJ_DESTROY(verify); + HcfObjDestroy(verify); HcfFree(verifyData.data); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } } diff --git a/test/unittest/src/crypto_x509_cert_chain_validator_test.cpp b/test/unittest/src/crypto_x509_cert_chain_validator_test.cpp index 14b7468279236e77939cc98a3a68a3c72a68e0b3..b339a67210e9926ce890a7cf8d6d07f46e6a9c17 100644 --- a/test/unittest/src/crypto_x509_cert_chain_validator_test.cpp +++ b/test/unittest/src/crypto_x509_cert_chain_validator_test.cpp @@ -19,8 +19,10 @@ #include "cert_chain_validator.h" #include "blob.h" +#include "memory_mock.h" #include "object_base.h" #include "result.h" +#include "x509_cert_chain_validator_openssl.h" using namespace std; using namespace testing::ext; @@ -35,6 +37,7 @@ public: }; constexpr int32_t CERT_HEADER_LEN = 2; +constexpr int32_t INVALID_MAX_CERT_LEN = 8194; static char g_caCert[] = "-----BEGIN CERTIFICATE-----\r\n" @@ -141,8 +144,16 @@ static char g_invalidCaCert[] = "3hd5yG48AaYNKhJ26auBrOARpJe/ktKZTMuU3zHuPRtv3Wtdiw==\r\n" "-----END CERTIFICATE-----\r\n"; -void CryptoX509CertChainValidatorTest::SetUpTestCase() {} -void CryptoX509CertChainValidatorTest::TearDownTestCase() {} +static HcfCertChainValidator *g_validator = nullptr; + +void CryptoX509CertChainValidatorTest::SetUpTestCase() +{ + (void)HcfCertChainValidatorCreate("PKIX", &g_validator); +} +void CryptoX509CertChainValidatorTest::TearDownTestCase() +{ + HcfObjDestroy(g_validator); +} void CryptoX509CertChainValidatorTest::SetUp() { @@ -154,19 +165,14 @@ void CryptoX509CertChainValidatorTest::TearDown() HWTEST_F(CryptoX509CertChainValidatorTest, GetAlgorithm001, TestSize.Level0) { - HcfCertChainValidator *pathValidator = nullptr; - HcfResult res = HcfCertChainValidatorCreate("PKIX", &pathValidator); - EXPECT_EQ(res, HCF_SUCCESS); - EXPECT_NE(pathValidator, nullptr); - const char *algo = pathValidator->getAlgorithm(pathValidator); + const char *algo = g_validator->getAlgorithm(g_validator); EXPECT_NE(algo, nullptr); if (algo == nullptr) { - OH_HCF_OBJ_DESTROY(pathValidator); + HcfObjDestroy(g_validator); return; } string st("PKIX"); ASSERT_STREQ(algo, st.c_str()); - OH_HCF_OBJ_DESTROY(pathValidator); } HWTEST_F(CryptoX509CertChainValidatorTest, GetAlgorithm002, TestSize.Level0) @@ -180,10 +186,7 @@ HWTEST_F(CryptoX509CertChainValidatorTest, GetAlgorithm002, TestSize.Level0) /* valid cert chain. */ HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest001, TestSize.Level0) { - HcfCertChainValidator *pathValidator = nullptr; - HcfResult res = HcfCertChainValidatorCreate("PKIX", &pathValidator); - EXPECT_EQ(res, HCF_SUCCESS); - EXPECT_NE(pathValidator, nullptr); + HcfResult res = HCF_SUCCESS; HcfCertChainData certsData = { 0 }; certsData.format = HCF_FORMAT_PEM; certsData.count = 2; /* level-2 cert chain. */ @@ -211,20 +214,16 @@ HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest001, TestSize.Level0) goto OUT; } - res = pathValidator->validate(pathValidator, &certsData); + res = g_validator->validate(g_validator, &certsData); EXPECT_EQ(res, HCF_SUCCESS); OUT: free(certsData.data); - OH_HCF_OBJ_DESTROY(pathValidator); } /* invalid cert chain. */ HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest002, TestSize.Level0) { - HcfCertChainValidator *pathValidator = nullptr; - HcfResult res = HcfCertChainValidatorCreate("PKIX", &pathValidator); - EXPECT_EQ(res, HCF_SUCCESS); - EXPECT_NE(pathValidator, nullptr); + HcfResult res = HCF_SUCCESS; HcfCertChainData certsData = { 0 }; certsData.format = HCF_FORMAT_PEM; certsData.count = 3; /* level-3 cert chain. */ @@ -265,10 +264,122 @@ HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest002, TestSize.Level0) goto OUT; } - res = pathValidator->validate(pathValidator, &certsData); + res = g_validator->validate(g_validator, &certsData); + EXPECT_NE(res, HCF_SUCCESS); +OUT: + free(certsData.data); +} + +/* invalid cert chain data len. */ +HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest003, TestSize.Level0) +{ + HcfCertChainData certsData = { 0 }; + certsData.format = HCF_FORMAT_PEM; + certsData.count = 3; /* level-3 cert chain. */ + certsData.dataLen = INVALID_MAX_CERT_LEN; + certsData.data = (uint8_t *)malloc(certsData.dataLen); + EXPECT_NE(certsData.data, nullptr); + if (certsData.data == nullptr) { + return; + } + + HcfResult res = g_validator->validate(g_validator, &certsData); + EXPECT_NE(res, HCF_SUCCESS); + free(certsData.data); +} + +/* invalid cert number(1). */ +HWTEST_F(CryptoX509CertChainValidatorTest, VerifyTest004, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfCertChainData certsData = { 0 }; + certsData.format = HCF_FORMAT_PEM; + certsData.count = 1; /* level-3 cert chain. */ + uint32_t caCertLen = strlen(g_caCert) + 1; + certsData.dataLen = CERT_HEADER_LEN + caCertLen; + certsData.data = (uint8_t *)malloc(certsData.dataLen); + EXPECT_NE(certsData.data, nullptr); + if (certsData.data == nullptr) { + return; + } + if (memcpy_s(certsData.data, + CERT_HEADER_LEN + caCertLen, &caCertLen, CERT_HEADER_LEN) != EOK) { + goto OUT; + } + if (memcpy_s(certsData.data + CERT_HEADER_LEN, + caCertLen, g_caCert, caCertLen) != EOK) { + goto OUT; + } + + res = g_validator->validate(g_validator, &certsData); EXPECT_NE(res, HCF_SUCCESS); OUT: free(certsData.data); - OH_HCF_OBJ_DESTROY(pathValidator); +} + +static const char *GetInvalidValidatorClass(void) +{ + return "INVALID_VALIDATOR_CLASS"; +} + + +HWTEST_F(CryptoX509CertChainValidatorTest, NullInput, TestSize.Level0) +{ + HcfResult res = HcfCertChainValidatorCreate("PKIX", nullptr); + EXPECT_NE(res, HCF_SUCCESS); + res = g_validator->validate(g_validator, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + const char *algo = g_validator->getAlgorithm(nullptr); + EXPECT_EQ(algo, nullptr); + (void)g_validator->base.destroy(nullptr); +} + +HWTEST_F(CryptoX509CertChainValidatorTest, InvalidClass, TestSize.Level0) +{ + HcfCertChainValidator invalidValidator; + invalidValidator.base.getClass = GetInvalidValidatorClass; + HcfCertChainData certsData = { 0 }; + HcfResult res = g_validator->validate(&invalidValidator, &certsData); + EXPECT_NE(res, HCF_SUCCESS); + const char *algo = g_validator->getAlgorithm(&invalidValidator); + EXPECT_EQ(algo, nullptr); + (void)g_validator->base.destroy(&(invalidValidator.base)); +} + +HWTEST_F(CryptoX509CertChainValidatorTest, NullSpiInput, TestSize.Level0) +{ + HcfCertChainValidatorSpi *spiObj = nullptr; + HcfResult res = HcfCertChainValidatorSpiCreate(nullptr); + EXPECT_NE(res, HCF_SUCCESS); + res = HcfCertChainValidatorSpiCreate(&spiObj); + EXPECT_EQ(res, HCF_SUCCESS); + res = spiObj->engineValidate(spiObj, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + (void)spiObj->base.destroy(nullptr); +} + +HWTEST_F(CryptoX509CertChainValidatorTest, InvalidSpiClass, TestSize.Level0) +{ + HcfCertChainValidatorSpi *spiObj = nullptr; + HcfResult res = HcfCertChainValidatorSpiCreate(&spiObj); + HcfCertChainValidatorSpi invalidSpi; + invalidSpi.base.getClass = GetInvalidValidatorClass; + HcfArray data = { 0 }; + res = spiObj->engineValidate(&invalidSpi, &data); + EXPECT_NE(res, HCF_SUCCESS); + (void)spiObj->base.destroy(&(invalidSpi.base)); +} + +HWTEST_F(CryptoX509CertChainValidatorTest, InvalidMalloc, TestSize.Level0) +{ + SetMockFlag(true); + HcfCertChainValidator *pathValidator = nullptr; + HcfResult res = HcfCertChainValidatorCreate("PKIX", &pathValidator); + EXPECT_EQ(res, HCF_ERR_MALLOC); + HcfCertChainData certsData = { 0 }; + certsData.dataLen = 1; + res = g_validator->validate(g_validator, &certsData); + EXPECT_NE(res, HCF_SUCCESS); + SetMockFlag(false); } } \ No newline at end of file diff --git a/test/unittest/src/crypto_x509_certificate_test.cpp b/test/unittest/src/crypto_x509_certificate_test.cpp index 288ab1ddf9f63206141f7a04019ab67e3a704c35..171309217782250429d38d0cfdac62c661959ffc 100644 --- a/test/unittest/src/crypto_x509_certificate_test.cpp +++ b/test/unittest/src/crypto_x509_certificate_test.cpp @@ -18,6 +18,8 @@ #include "x509_certificate.h" #include "blob.h" +#include "memory_mock.h" +#include "x509_certificate_openssl.h" using namespace std; using namespace testing::ext; @@ -250,8 +252,21 @@ constexpr int TEST_CERT_VERSION = 3; constexpr int TEST_CERT_CHAIN_LEN = 2; constexpr int TEST_CERT_SERIAL_NUMBER = 272; -void CryptoX509CertificateTest::SetUpTestCase() {} -void CryptoX509CertificateTest::TearDownTestCase() {} +static HcfX509Certificate *g_x509CertObj = nullptr; + +void CryptoX509CertificateTest::SetUpTestCase() +{ + HcfEncodingBlob inStream = { 0 }; + inStream.data = (uint8_t *)g_testSelfSignedCaCert; + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = strlen(g_testSelfSignedCaCert) + 1; + (void)HcfX509CertificateCreate(&inStream, &g_x509CertObj); +} + +void CryptoX509CertificateTest::TearDownTestCase() +{ + HcfObjDestroy(g_x509CertObj); +} void CryptoX509CertificateTest::SetUp() { @@ -277,7 +292,7 @@ HWTEST_F(CryptoX509CertificateTest, GenerateCert001, TestSize.Level0) HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(x509Cert, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* Invalid input. */ @@ -288,7 +303,7 @@ HWTEST_F(CryptoX509CertificateTest, GenerateCert002, TestSize.Level0) HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(x509Cert, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* Invalid PEM format. */ @@ -302,22 +317,14 @@ HWTEST_F(CryptoX509CertificateTest, GenerateCert003, TestSize.Level0) HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(x509Cert, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* Valid DER format. */ HWTEST_F(CryptoX509CertificateTest, GenerateCert004, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); HcfEncodingBlob derBlob = { 0 }; - ret = x509Cert->base.getEncoded((HcfCertificate *)x509Cert, &derBlob); + HcfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, &derBlob); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(derBlob.data, nullptr); EXPECT_EQ(derBlob.encodingFormat, HCF_FORMAT_DER); @@ -327,29 +334,19 @@ HWTEST_F(CryptoX509CertificateTest, GenerateCert004, TestSize.Level0) EXPECT_NE(certFromDerData, nullptr); free(derBlob.data); - OH_HCF_OBJ_DESTROY(certFromDerData); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(certFromDerData); } /* verify self signed cert. */ HWTEST_F(CryptoX509CertificateTest, Verify001, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); HcfPubKey *keyOut = nullptr; - ret = x509Cert->base.getPublicKey((HcfCertificate *)x509Cert, &keyOut); + HcfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(keyOut, nullptr); - ret = x509Cert->base.verify((HcfCertificate *)x509Cert, keyOut); + ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, keyOut); EXPECT_EQ(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyOut); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(keyOut); } /* use root ca cert's public key to verify next cert. */ @@ -378,29 +375,20 @@ HWTEST_F(CryptoX509CertificateTest, Verify002, TestSize.Level0) EXPECT_NE(rootCert, nullptr); ret = secondCert->base.verify((HcfCertificate *)secondCert, rootkeyOut); EXPECT_EQ(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(rootkeyOut); - OH_HCF_OBJ_DESTROY(rootCert); - OH_HCF_OBJ_DESTROY(secondCert); + HcfObjDestroy(rootkeyOut); + HcfObjDestroy(rootCert); + HcfObjDestroy(secondCert); } /* verify cert with wrong pub key. */ HWTEST_F(CryptoX509CertificateTest, Verify003, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - HcfX509Certificate *rootCert = nullptr; HcfEncodingBlob root = { 0 }; root.data = (uint8_t *)g_rootCert; root.encodingFormat = HCF_FORMAT_PEM; root.len = strlen(g_rootCert) + 1; - ret = HcfX509CertificateCreate(&root, &rootCert); + HcfResult ret = HcfX509CertificateCreate(&root, &rootCert); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(rootCert, nullptr); HcfPubKey *rootkeyOut = nullptr; @@ -408,509 +396,250 @@ HWTEST_F(CryptoX509CertificateTest, Verify003, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(rootkeyOut, nullptr); - ret = x509Cert->base.verify((HcfCertificate *)x509Cert, rootkeyOut); + ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, rootkeyOut); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(rootkeyOut); - OH_HCF_OBJ_DESTROY(rootCert); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(rootkeyOut); + HcfObjDestroy(rootCert); } /* verify cert with invalid input pub key. */ HWTEST_F(CryptoX509CertificateTest, Verify004, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - HcfPubKey *keyOut = nullptr; - ret = x509Cert->base.verify((HcfCertificate *)x509Cert, keyOut); + HcfResult ret = g_x509CertObj->base.verify((HcfCertificate *)g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetEncoded001, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; HcfEncodingBlob encodingBlob = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - - ret = x509Cert->base.getEncoded((HcfCertificate *)x509Cert, &encodingBlob); + HcfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, &encodingBlob); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(encodingBlob.data, nullptr); EXPECT_EQ(encodingBlob.encodingFormat, HCF_FORMAT_DER); - free(encodingBlob.data); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfEncodingBlobDataFree(&encodingBlob); } /* Invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetEncoded002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - - ret = x509Cert->base.getEncoded((HcfCertificate *)x509Cert, nullptr); + HcfResult ret = g_x509CertObj->base.getEncoded((HcfCertificate *)g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetPublicKey, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; HcfPubKey *keyOut = nullptr; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - - ret = x509Cert->base.getPublicKey((HcfCertificate *)x509Cert, &keyOut); + HcfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(keyOut, nullptr); - OH_HCF_OBJ_DESTROY(keyOut); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(keyOut); } /* Input valid date. YYMMDDHHMMSSZ */ HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate001, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); const char *date = "231018162433Z"; - ret = x509Cert->checkValidityWithDate(x509Cert, date); + // validatetime :2022/08/19 - 2032/08/16 + HcfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); EXPECT_EQ(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } /* Input valid date. time format: YYYYMMDDHHMMSSZ */ HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); const char *date = "20231018162433Z"; - ret = x509Cert->checkValidityWithDate(x509Cert, date); + // validatetime :2022/08/19 - 2032/08/16 + HcfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); EXPECT_EQ(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } /* Input invalid date--expiered. */ HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate003, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); const char *date = "20991018162433Z"; - ret = x509Cert->checkValidityWithDate(x509Cert, date); + // validatetime :2022/08/19 - 2032/08/16 + HcfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); EXPECT_EQ(ret, HCF_ERR_CERT_HAS_EXPIRED); - OH_HCF_OBJ_DESTROY(x509Cert); } /* Input invalid date. */ HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate004, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); const char *date = "20191018162433Z"; - ret = x509Cert->checkValidityWithDate(x509Cert, date); + // validatetime :2022/08/19 - 2032/08/16 + HcfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); EXPECT_EQ(ret, HCF_ERR_CERT_NOT_YET_VALID); - OH_HCF_OBJ_DESTROY(x509Cert); } /* Input invalid date form. */ HWTEST_F(CryptoX509CertificateTest, CheckValidityWithDate005, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); const char *date = "20191018"; - ret = x509Cert->checkValidityWithDate(x509Cert, date); + // validatetime :2022/08/19 - 2032/08/16 + HcfResult ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetVersion, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - long ver = x509Cert->getVersion(x509Cert); + long ver = g_x509CertObj->getVersion(g_x509CertObj); EXPECT_EQ(ver, TEST_CERT_VERSION); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSerialNumber, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); + HcfBlob out = { nullptr, 0}; + HcfResult ret = g_x509CertObj->getSerialNumber(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - long serialNumber = x509Cert->getSerialNumber(x509Cert); - EXPECT_EQ(serialNumber, TEST_CERT_SERIAL_NUMBER); - OH_HCF_OBJ_DESTROY(x509Cert); -} + EXPECT_NE(out.data, nullptr); + EXPECT_EQ(out.len, 2); /* out size: 2 bytes */ + EXPECT_EQ(out.data[0] * 0x100 + out.data[1], TEST_CERT_SERIAL_NUMBER); + HcfBlobDataClearAndFree(&out);} HWTEST_F(CryptoX509CertificateTest, GetIssuerName001, TestSize.Level0) { HcfBlob out = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getIssuerName(x509Cert, &out); + HcfResult ret = g_x509CertObj->getIssuerName(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); - printf("the IssuerDN = %s.\n", out.data); HcfBlobDataClearAndFree(&out); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetIssuerName002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getIssuerName(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getIssuerName(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSubjectName001, TestSize.Level0) { HcfBlob out = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSubjectName(x509Cert, &out); + HcfResult ret = g_x509CertObj->getSubjectName(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); - printf("the SubjectDN = %s.\n", out.data); HcfBlobDataClearAndFree(&out); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetSubjectName002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSubjectName(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getSubjectName(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetNotBeforeTime001, TestSize.Level0) { HcfBlob out = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getNotBeforeTime(x509Cert, &out); + HcfResult ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); HcfBlobDataClearAndFree(&out); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetNotBeforeTime002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getNotBeforeTime(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetNotAfterTime001, TestSize.Level0) { HcfBlob out = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; // validatetime :2022/08/19 - 2032/08/16 - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getNotAfterTime(x509Cert, &out); + HcfResult ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); HcfBlobDataClearAndFree(&out); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetNotAfterTime002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getNotAfterTime(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSignature001, TestSize.Level0) { HcfBlob sigOut = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignature(x509Cert, &sigOut); + HcfResult ret = g_x509CertObj->getSignature(g_x509CertObj, &sigOut); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(sigOut.data, nullptr); HcfBlobDataClearAndFree(&sigOut); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetSignature002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignature(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getSignature(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgName001, TestSize.Level0) { HcfBlob sigAlgName = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgName(x509Cert, &sigAlgName); + HcfResult ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, &sigAlgName); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(sigAlgName.data, nullptr); HcfBlobDataClearAndFree(&sigAlgName); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgName002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgName(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgOid001, TestSize.Level0) { - HcfBlob sigAlgOID = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); + HcfBlob sigAlgOid = { 0 }; + HcfResult ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, &sigAlgOid); EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgOid(x509Cert, &sigAlgOID); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(sigAlgOID.data, nullptr); - HcfBlobDataClearAndFree(&sigAlgOID); - OH_HCF_OBJ_DESTROY(x509Cert); + EXPECT_NE(sigAlgOid.data, nullptr); + HcfBlobDataClearAndFree(&sigAlgOid); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgOid002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgOid(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgParams001, TestSize.Level0) { HcfBlob sigAlgParamsOut = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgParams(x509Cert, &sigAlgParamsOut); + HcfResult ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, &sigAlgParamsOut); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(sigAlgParamsOut.data, nullptr); HcfBlobDataClearAndFree(&sigAlgParamsOut); - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetSignatureAlgParams002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSignatureAlgParams(x509Cert, nullptr); + HcfResult ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetKeyUsage, TestSize.Level0) { HcfBlob out = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getKeyUsage(x509Cert, &out); + HcfResult ret = g_x509CertObj->getKeyUsage(g_x509CertObj, &out); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); HcfBlobDataClearAndFree(&out); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetExtKeyUsage001, TestSize.Level0) { HcfArray keyUsageOut = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getExtKeyUsage(x509Cert, &keyUsageOut); + HcfResult ret = g_x509CertObj->getExtKeyUsage(g_x509CertObj, &keyUsageOut); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(keyUsageOut.data, nullptr); HcfArrayDataClearAndFree(&keyUsageOut); - OH_HCF_OBJ_DESTROY(x509Cert); } /* Cert which has no extended key usage. */ @@ -928,7 +657,7 @@ HWTEST_F(CryptoX509CertificateTest, GetExtKeyUsage002, TestSize.Level0) ret = x509Cert->getExtKeyUsage(x509Cert, &keyUsageOut); EXPECT_EQ(ret, HCF_ERR_CRYPTO_OPERATION); EXPECT_EQ(keyUsageOut.data, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* not a CA cert */ @@ -944,57 +673,30 @@ HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints001, TestSize.Level0) EXPECT_NE(x509Cert, nullptr); int32_t pathLen = x509Cert->getBasicConstraints(x509Cert); EXPECT_EQ(pathLen, -1); /* cert path len is only valid for CA. */ - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* CA cert */ HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints002, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - int32_t pathLen = x509Cert->getBasicConstraints(x509Cert); + int32_t pathLen = g_x509CertObj->getBasicConstraints(g_x509CertObj); EXPECT_EQ(pathLen, TEST_CERT_CHAIN_LEN); /* g_testSelfSignedCaCert is CA and it's path len is 2. */ - OH_HCF_OBJ_DESTROY(x509Cert); } /* invalid input. */ HWTEST_F(CryptoX509CertificateTest, GetBasicConstraints003, TestSize.Level0) { - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - int32_t pathLen = x509Cert->getBasicConstraints(nullptr); + int32_t pathLen = g_x509CertObj->getBasicConstraints(nullptr); EXPECT_EQ(pathLen, -1); - OH_HCF_OBJ_DESTROY(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames001, TestSize.Level0) { HcfArray outName = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getSubjectAltNames(x509Cert, &outName); + HcfResult ret = g_x509CertObj->getSubjectAltNames(g_x509CertObj, &outName); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(outName.data, nullptr); HcfArrayDataClearAndFree(&outName); - OH_HCF_OBJ_DESTROY(x509Cert); } /* cert without subject alternative names. */ @@ -1012,7 +714,7 @@ HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames002, TestSize.Level0) ret = x509Cert->getSubjectAltNames(x509Cert, &outName); EXPECT_EQ(ret, HCF_ERR_CRYPTO_OPERATION); EXPECT_EQ(outName.data, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* invalid input. */ @@ -1028,25 +730,16 @@ HWTEST_F(CryptoX509CertificateTest, GetSubjectAltNames003, TestSize.Level0) EXPECT_NE(x509Cert, nullptr); ret = x509Cert->getSubjectAltNames(x509Cert, nullptr); EXPECT_EQ(ret, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames001, TestSize.Level0) { HcfArray outName = { 0 }; - HcfX509Certificate *x509Cert = nullptr; - HcfEncodingBlob inStream = { 0 }; - inStream.data = (uint8_t *)g_testSelfSignedCaCert; - inStream.encodingFormat = HCF_FORMAT_PEM; - inStream.len = strlen(g_testSelfSignedCaCert) + 1; - HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); - EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(x509Cert, nullptr); - ret = x509Cert->getIssuerAltNames(x509Cert, &outName); + HcfResult ret = g_x509CertObj->getIssuerAltNames(g_x509CertObj, &outName); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(outName.data, nullptr); HcfArrayDataClearAndFree(&outName); - OH_HCF_OBJ_DESTROY(x509Cert); } /* cert without issuer alternative names. */ @@ -1064,7 +757,7 @@ HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames002, TestSize.Level0) ret = x509Cert->getIssuerAltNames(x509Cert, &outName); EXPECT_EQ(ret, HCF_ERR_CRYPTO_OPERATION); EXPECT_EQ(outName.data, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } /* invalid input. */ @@ -1080,6 +773,211 @@ HWTEST_F(CryptoX509CertificateTest, GetIssuerAltNames003, TestSize.Level0) EXPECT_NE(x509Cert, nullptr); ret = x509Cert->getIssuerAltNames(x509Cert, nullptr); EXPECT_EQ(ret, HCF_INVALID_PARAMS); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); +} + +HWTEST_F(CryptoX509CertificateTest, NullInput, TestSize.Level0) +{ + (void)HcfX509CertificateCreate(nullptr, nullptr); + HcfPubKey *keyOut = nullptr; + HcfResult ret = g_x509CertObj->base.getPublicKey((HcfCertificate *)g_x509CertObj, &keyOut); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(keyOut, nullptr); + (void)g_x509CertObj->base.base.destroy(nullptr); + (void)keyOut->base.getAlgorithm(&(keyOut->base)); + (void)keyOut->base.getEncoded(&(keyOut->base), nullptr); + (void)keyOut->base.getFormat(&(keyOut->base)); + ret = g_x509CertObj->base.verify(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509CertObj->base.getEncoded(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509CertObj->base.getPublicKey(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + (void)g_x509CertObj->checkValidityWithDate(nullptr, nullptr); + (void)g_x509CertObj->getVersion(nullptr); + (void)g_x509CertObj->getSerialNumber(nullptr, nullptr); + (void)g_x509CertObj->getIssuerName(nullptr, nullptr); + (void)g_x509CertObj->getSubjectName(nullptr, nullptr); + (void)g_x509CertObj->getNotBeforeTime(nullptr, nullptr); + (void)g_x509CertObj->getNotAfterTime(nullptr, nullptr); + (void)g_x509CertObj->getSignature(nullptr, nullptr); + (void)g_x509CertObj->getSignatureAlgName(nullptr, nullptr); + (void)g_x509CertObj->getSignatureAlgOid(nullptr, nullptr); + (void)g_x509CertObj->getSignatureAlgParams(nullptr, nullptr); + (void)g_x509CertObj->getKeyUsage(nullptr, nullptr); + (void)g_x509CertObj->getExtKeyUsage(nullptr, nullptr); + (void)g_x509CertObj->getBasicConstraints(nullptr); + (void)g_x509CertObj->getSubjectAltNames(nullptr, nullptr); + (void)g_x509CertObj->getIssuerAltNames(nullptr, nullptr); + HcfObjDestroy(keyOut); +} + +HWTEST_F(CryptoX509CertificateTest, NullSpiInput, TestSize.Level0) +{ + HcfX509CertificateSpi *spiObj = nullptr; + HcfEncodingBlob inStream = { 0 }; + inStream.data = (uint8_t *)g_testSelfSignedCaCert; + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = strlen(g_testSelfSignedCaCert) + 1; + (void)OpensslX509CertSpiCreate(nullptr, nullptr); + HcfResult ret = OpensslX509CertSpiCreate(&inStream, &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + ret = spiObj->engineVerify(nullptr, nullptr); + ret = spiObj->engineGetEncoded(nullptr, nullptr); + ret = spiObj->engineGetPublicKey(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineCheckValidityWithDate(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + long ver = spiObj->engineGetVersion(nullptr); + EXPECT_EQ(ver, -1); + ret = spiObj->engineGetSerialNumber(nullptr, nullptr); + ret = spiObj->engineGetIssuerName(nullptr, nullptr); + ret = spiObj->engineGetSubjectName(nullptr, nullptr); + ret = spiObj->engineGetNotBeforeTime(nullptr, nullptr); + ret = spiObj->engineGetNotAfterTime(nullptr, nullptr); + ret = spiObj->engineGetSignature(nullptr, nullptr); + ret = spiObj->engineGetSignatureAlgName(nullptr, nullptr); + ret = spiObj->engineGetSignatureAlgOid(nullptr, nullptr); + ret = spiObj->engineGetSignatureAlgParams(nullptr, nullptr); + ret = spiObj->engineGetKeyUsage(nullptr, nullptr); + ret = spiObj->engineGetExtKeyUsage(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + long basicLen = spiObj->engineGetBasicConstraints(nullptr); + EXPECT_EQ(basicLen, -1); + ret = spiObj->engineGetSubjectAltNames(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetIssuerAltNames(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(spiObj); +} + +static const char *GetInvalidCertClass(void) +{ + return "INVALID_CERT_CLASS"; +} + +HWTEST_F(CryptoX509CertificateTest, InvalidSpiClass, TestSize.Level0) +{ + HcfX509CertificateSpi *spiObj = nullptr; + HcfX509CertificateSpi invalidSpi = { {0} }; + invalidSpi.base.getClass = GetInvalidCertClass; + HcfBlob invalidOut = { 0 }; + HcfEncodingBlob inStream = { 0 }; + inStream.data = (uint8_t *)g_testSelfSignedCaCert; + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = strlen(g_testSelfSignedCaCert) + 1; + HcfResult ret = OpensslX509CertSpiCreate(&inStream, &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + HcfPubKey pubKey; + ret = spiObj->engineVerify(&invalidSpi, &pubKey); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetEncoded(&invalidSpi, &inStream); + EXPECT_NE(ret, HCF_SUCCESS); + HcfPubKey *pubKeyOut = nullptr; + ret = spiObj->engineGetPublicKey(&invalidSpi, &pubKeyOut); + EXPECT_NE(ret, HCF_SUCCESS); + const char *date = "2020"; + ret = spiObj->engineCheckValidityWithDate(&invalidSpi, date); + EXPECT_NE(ret, HCF_SUCCESS); + long ver = spiObj->engineGetVersion(&invalidSpi); + EXPECT_EQ(ver, -1); + ret = spiObj->engineGetSerialNumber(&invalidSpi, &invalidOut); + ret = spiObj->engineGetIssuerName(&invalidSpi, &invalidOut); + ret = spiObj->engineGetSubjectName(&invalidSpi, &invalidOut); + ret = spiObj->engineGetNotBeforeTime(&invalidSpi, &invalidOut); + ret = spiObj->engineGetNotAfterTime(&invalidSpi, &invalidOut); + ret = spiObj->engineGetSignature(&invalidSpi, &invalidOut); + ret = spiObj->engineGetSignatureAlgName(&invalidSpi, &invalidOut); + ret = spiObj->engineGetSignatureAlgOid(&invalidSpi, &invalidOut); + ret = spiObj->engineGetSignatureAlgParams(&invalidSpi, &invalidOut); + ret = spiObj->engineGetKeyUsage(&invalidSpi, &invalidOut); + HcfArray invalidArr = { 0 }; + ret = spiObj->engineGetExtKeyUsage(&invalidSpi, &invalidArr); + long basicLen = spiObj->engineGetBasicConstraints(&invalidSpi); + EXPECT_EQ(basicLen, -1); + ret = spiObj->engineGetSubjectAltNames(&invalidSpi, &invalidArr); + ret = spiObj->engineGetIssuerAltNames(&invalidSpi, &invalidArr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoX509CertificateTest, InvalidCertClass, TestSize.Level0) +{ + HcfX509Certificate invalidCert; + invalidCert.base.base.getClass = GetInvalidCertClass; + HcfBlob invalidOut = { 0 }; + + HcfEncodingBlob inStream = { 0 }; + HcfPubKey keyOut; + g_x509CertObj->base.base.destroy(&(invalidCert.base.base)); + HcfResult ret = g_x509CertObj->base.verify(&(invalidCert.base), &keyOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509CertObj->base.getEncoded(&(invalidCert.base), &inStream); + EXPECT_NE(ret, HCF_SUCCESS); + HcfPubKey *pubKeyOut = nullptr; + ret = g_x509CertObj->base.getPublicKey(&(invalidCert.base), &pubKeyOut); + EXPECT_NE(ret, HCF_SUCCESS); + const char *date = "2020"; + ret = g_x509CertObj->checkValidityWithDate(&invalidCert, date); + long ver = g_x509CertObj->getVersion(&invalidCert); + EXPECT_EQ(ver, -1); + ret = g_x509CertObj->getSerialNumber(&invalidCert, &invalidOut); + ret = g_x509CertObj->getIssuerName(&invalidCert, &invalidOut); + ret = g_x509CertObj->getSubjectName(&invalidCert, &invalidOut); + ret = g_x509CertObj->getNotBeforeTime(&invalidCert, &invalidOut); + ret = g_x509CertObj->getNotAfterTime(&invalidCert, &invalidOut); + ret = g_x509CertObj->getSignature(&invalidCert, &invalidOut); + ret = g_x509CertObj->getSignatureAlgName(&invalidCert, &invalidOut); + ret = g_x509CertObj->getSignatureAlgOid(&invalidCert, &invalidOut); + ret = g_x509CertObj->getSignatureAlgParams(&invalidCert, &invalidOut); + ret = g_x509CertObj->getKeyUsage(&invalidCert, &invalidOut); + HcfArray invalidArr = { 0 }; + ret = g_x509CertObj->getExtKeyUsage(&invalidCert, &invalidArr); + long basicLen = g_x509CertObj->getBasicConstraints(&invalidCert); + EXPECT_EQ(basicLen, -1); + ret = g_x509CertObj->getSubjectAltNames(&invalidCert, &invalidArr); + ret = g_x509CertObj->getIssuerAltNames(&invalidCert, &invalidArr); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoX509CertificateTest, InvalidMalloc, TestSize.Level0) +{ + SetMockFlag(true); + HcfX509Certificate *x509Cert = nullptr; + HcfEncodingBlob inStream = { 0 }; + inStream.data = (uint8_t *)g_secondCert; + inStream.encodingFormat = HCF_FORMAT_PEM; + inStream.len = strlen(g_secondCert) + 1; + HcfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert); + EXPECT_NE(ret, HCF_SUCCESS); + HcfBlob out = { 0 }; + HcfArray arr = { 0 }; + ret = g_x509CertObj->base.getEncoded(&(g_x509CertObj->base), &inStream); + EXPECT_NE(ret, HCF_SUCCESS); + HcfPubKey *pubKeyOut = nullptr; + ret = g_x509CertObj->base.getPublicKey(&(g_x509CertObj->base), &pubKeyOut); + EXPECT_NE(ret, HCF_SUCCESS); + const char *date = "2020"; + ret = g_x509CertObj->checkValidityWithDate(g_x509CertObj, date); + ret = g_x509CertObj->getIssuerName(g_x509CertObj, &out); + ret = g_x509CertObj->getSubjectName(g_x509CertObj, &out); + ret = g_x509CertObj->getNotBeforeTime(g_x509CertObj, &out); + ret = g_x509CertObj->getNotAfterTime(g_x509CertObj, &out); + ret = g_x509CertObj->getSignature(g_x509CertObj, &out); + ret = g_x509CertObj->getSignatureAlgName(g_x509CertObj, &out); + ret = g_x509CertObj->getSignatureAlgOid(g_x509CertObj, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509CertObj->getSignatureAlgParams(g_x509CertObj, &out); + ret = g_x509CertObj->getKeyUsage(g_x509CertObj, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509CertObj->getExtKeyUsage(g_x509CertObj, &arr); + ret = g_x509CertObj->getSubjectAltNames(g_x509CertObj, &arr); + ret = g_x509CertObj->getIssuerAltNames(g_x509CertObj, &arr); + EXPECT_NE(ret, HCF_SUCCESS); + SetMockFlag(false); } } \ No newline at end of file diff --git a/test/unittest/src/crypto_x509_crl_test.cpp b/test/unittest/src/crypto_x509_crl_test.cpp index c850ccb4a28be15f13679be77f56ce6ec5c88428..289b30ac433ed6a0b2e876b437a091865b87fa96 100644 --- a/test/unittest/src/crypto_x509_crl_test.cpp +++ b/test/unittest/src/crypto_x509_crl_test.cpp @@ -22,9 +22,11 @@ #include "cipher.h" #include "key_pair.h" #include "memory.h" +#include "memory_mock.h" #include "openssl_class.h" #include "x509_crl.h" #include "x509_crl_openssl.h" +#include"x509_crl_entry_openssl.h" using namespace std; using namespace testing::ext; @@ -122,7 +124,6 @@ public: static unsigned char *GetCrlStream() { - int ret, len; unsigned char *buf, *p; time_t t; X509_NAME *issuer; @@ -141,56 +142,58 @@ static unsigned char *GetCrlStream() // Set version crl = X509_CRL_new(); - ret = X509_CRL_set_version(crl, TEST_VERSION); + (void)X509_CRL_set_version(crl, TEST_VERSION); // Set Issuer issuer = X509_NAME_new(); - ret = X509_NAME_add_entry_by_NID(issuer, NID_commonName, V_ASN1_PRINTABLESTRING, - (const unsigned char *)"CRL issuer", 10, -1, 0); - ret = X509_CRL_set_issuer_name(crl, issuer); + + const char *tmp = "CRL issuer"; + (void)X509_NAME_add_entry_by_NID(issuer, NID_commonName, V_ASN1_PRINTABLESTRING, + reinterpret_cast(tmp), 10, -1, 0); + (void)X509_CRL_set_issuer_name(crl, issuer); // Set last time g_lastUpdate = ASN1_TIME_new(); t = time(nullptr); ASN1_TIME_set(g_lastUpdate, t + TEST_OFFSET_TIME); - ret = X509_CRL_set_lastUpdate(crl, g_lastUpdate); + (void)X509_CRL_set_lastUpdate(crl, g_lastUpdate); // Set next time g_nextUpdate = ASN1_TIME_new(); t = TEST_TIME; ASN1_TIME_set(g_nextUpdate, t); - ret = X509_CRL_set_nextUpdate(crl, g_nextUpdate); + (void)X509_CRL_set_nextUpdate(crl, g_nextUpdate); // Add serial number revoked = X509_REVOKED_new(); serial = ASN1_INTEGER_new(); - ret = ASN1_INTEGER_set(serial, TEST_SN); - ret = X509_REVOKED_set_serialNumber(revoked, serial); + (void)ASN1_INTEGER_set(serial, TEST_SN); + (void)X509_REVOKED_set_serialNumber(revoked, serial); // Set revocationDate g_rvTime = ASN1_TIME_new(); t = TEST_TIME; ASN1_TIME_set(g_rvTime, t); - ret = X509_CRL_set_nextUpdate(crl, g_rvTime); - ret = X509_REVOKED_set_revocationDate(revoked, g_rvTime); - ret = X509_CRL_add0_revoked(crl, revoked); + (void)X509_CRL_set_nextUpdate(crl, g_rvTime); + (void)X509_REVOKED_set_revocationDate(revoked, g_rvTime); + (void)X509_CRL_add0_revoked(crl, revoked); // Sort - ret = X509_CRL_sort(crl); + (void)X509_CRL_sort(crl); // Sign - ret = X509_CRL_sign(crl, prikey, EVP_md5()); + (void)X509_CRL_sign(crl, prikey, EVP_md5()); - len = i2d_X509_CRL(crl, nullptr); + int len = i2d_X509_CRL(crl, nullptr); buf = (unsigned char *)malloc(len + TEST_OFFSET); p = buf; len = i2d_X509_CRL(crl, &p); // Get sign - const ASN1_BIT_STRING *ASN1Signature = NULL; - X509_CRL_get0_signature(crl, &ASN1Signature, NULL); - g_signatureStr = (unsigned char *)ASN1_STRING_get0_data(ASN1Signature); - g_signatureLen = ASN1_STRING_length(ASN1Signature); + const ASN1_BIT_STRING *asn1Signature = nullptr; + X509_CRL_get0_signature(crl, &asn1Signature, nullptr); + g_signatureStr = const_cast(ASN1_STRING_get0_data(asn1Signature)); + g_signatureLen = ASN1_STRING_length(asn1Signature); // Get Tbs i2d_re_X509_CRL_tbs(crl, &g_tbs); @@ -206,16 +209,16 @@ void CryptoX509CrlTest::SetUpTestCase() g_crlDerInStream->encodingFormat = HCF_FORMAT_DER; g_crlDerInStream->len = TEST_CRL_LEN; HcfX509CrlCreate(g_crlDerInStream, &x509Crl); - g_x509Crl = (HcfX509Crl *)x509Crl; + g_x509Crl = x509Crl; } void CryptoX509CrlTest::TearDownTestCase() { if (g_x509Crl != nullptr) { - OH_HCF_OBJ_DESTROY(g_x509Crl); + HcfObjDestroy(g_x509Crl); g_x509Crl = nullptr; } if (g_keyPair != nullptr) { - OH_HCF_OBJ_DESTROY(g_keyPair); + HcfObjDestroy(g_keyPair); g_keyPair = nullptr; } if (g_lastUpdate != nullptr) { @@ -250,7 +253,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest001, TestSize.Level0) HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(x509Crl, nullptr); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl create DER true @@ -260,7 +263,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest002, TestSize.Level0) HcfResult ret = HcfX509CrlCreate(g_crlDerInStream, &x509Crl); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(x509Crl, nullptr); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl create error | encodingFormat @@ -337,8 +340,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest011, TestSize.Level0) bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert); EXPECT_EQ(resIsRevoked, true); - OH_HCF_OBJ_DESTROY(x509Crl); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Crl); + HcfObjDestroy(x509Cert); } // Test crl isRevoked error | crl null @@ -356,7 +359,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest012, TestSize.Level0) bool resIsRevoked = g_x509Crl->base.isRevoked(nullptr, (HcfCertificate *)x509Cert); EXPECT_EQ(resIsRevoked, false); - OH_HCF_OBJ_DESTROY(x509Cert); + HcfObjDestroy(x509Cert); } // Test crl isRevoked error | x509Cert null @@ -374,7 +377,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest013, TestSize.Level0) bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, nullptr); EXPECT_EQ(resIsRevoked, false); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl isRevoked error | x509Crl error @@ -398,8 +401,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest014, TestSize.Level0) bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert); EXPECT_EQ(resIsRevoked, false); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); } // Test crl isRevoked error | x509Crl error @@ -427,8 +430,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest015, TestSize.Level0) bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert); EXPECT_EQ(resIsRevoked, false); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); } // Test crl GetType true @@ -446,7 +449,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest021, TestSize.Level0) const char *resStr = x509Crl->base.getType((HcfCrl *)x509Crl); EXPECT_STREQ(resStr, "X509"); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl GetType error @@ -464,7 +467,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest022, TestSize.Level0) const char *resStr = x509Crl->base.getType(nullptr); EXPECT_EQ(resStr, nullptr); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl getEncoded DER true @@ -477,7 +480,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest031, TestSize.Level0) ret = HcfX509CrlCreate(&inStreamInput, &crl2); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crl2, nullptr); - OH_HCF_OBJ_DESTROY(crl2); + HcfObjDestroy(crl2); HcfFree(inStreamInput.data); } @@ -502,8 +505,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest032, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crl2, nullptr); HcfFree(inStreamInput.data); - OH_HCF_OBJ_DESTROY(crl2); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(crl2); + HcfObjDestroy(x509Crl); } // Test crl getEncoded error @@ -545,8 +548,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest042, TestSize.Level0) HcfResult ret = g_x509Crl->verify(g_x509Crl, keyPair->pubKey); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(keyPair); - OH_HCF_OBJ_DESTROY(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); } // Test crl verify false @@ -578,7 +581,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest045, TestSize.Level0) ret = x509Crl->verify(x509Crl, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl getVersion true @@ -704,7 +707,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest091, TestSize.Level0) HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crlEntry, nullptr); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl getRevokedCert false @@ -744,9 +747,13 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest101, TestSize.Level0) HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crlEntry, nullptr); - long sn = crlEntry->getSerialNumber(crlEntry); - EXPECT_EQ(sn, 1000); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfBlob out = { nullptr, 0 }; + ret = crlEntry->getSerialNumber(crlEntry, &out); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_EQ(out.len, 2); /* out size: 2 bytes */ + EXPECT_EQ(out.data[0] * 0x100 + out.data[1], 1000); + HcfFree(out.data); + HcfObjDestroy(crlEntry); } // Test crl entry getSerialNumber false @@ -756,9 +763,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest102, TestSize.Level0) HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crlEntry, nullptr); - long sn = crlEntry->getSerialNumber(nullptr); - EXPECT_EQ(sn, -1); - OH_HCF_OBJ_DESTROY(crlEntry); + ret = crlEntry->getSerialNumber(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(crlEntry); } // Test crl entry getSerialNumber false @@ -768,9 +775,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest103, TestSize.Level0) HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(crlEntry, nullptr); - long sn = crlEntry->getSerialNumber(nullptr); - EXPECT_EQ(sn, -1); - OH_HCF_OBJ_DESTROY(crlEntry); + ret = crlEntry->getSerialNumber(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(crlEntry); } // Test crl entry getEncoded true @@ -785,7 +792,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest111, TestSize.Level0) ret = crlEntry->getEncoded(crlEntry, &encodingBlob); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(encodingBlob.data, nullptr); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); HcfFree(encodingBlob.data); } @@ -801,7 +808,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest112, TestSize.Level0) ret = crlEntry->getEncoded(nullptr, &encodingBlob); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(encodingBlob.data, nullptr); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getEncoded false @@ -814,7 +821,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest113, TestSize.Level0) ret = crlEntry->getEncoded(crlEntry, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getEncoded false @@ -827,7 +834,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest114, TestSize.Level0) ret = crlEntry->getEncoded(nullptr, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getCertIssuer true @@ -843,7 +850,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest121, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); EXPECT_STREQ("/CN=CRL issuer", (char *)out.data); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); HcfFree(out.data); } @@ -859,7 +866,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest122, TestSize.Level0) ret = crlEntry->getCertIssuer(nullptr, &out); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(out.data, nullptr); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getCertIssuer false @@ -872,7 +879,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest123, TestSize.Level0) ret = crlEntry->getCertIssuer(crlEntry, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getRevocationDate true @@ -888,7 +895,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest131, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(out.data, nullptr); EXPECT_STREQ((char *)g_rvTime->data, (char *)out.data); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); HcfFree(out.data); } @@ -904,7 +911,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest132, TestSize.Level0) ret = crlEntry->getRevocationDate(nullptr, &out); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(out.data, nullptr); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getRevocationDate false @@ -917,7 +924,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest133, TestSize.Level0) ret = crlEntry->getRevocationDate(crlEntry, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl getRevokedCertWithCert true @@ -954,9 +961,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest141, TestSize.Level0) EXPECT_NE(out.data, nullptr); EXPECT_STREQ("220829065953Z", (char *)out.data); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); + HcfObjDestroy(crlEntry); HcfFree(out.data); } @@ -995,9 +1002,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest142, TestSize.Level0) EXPECT_STREQ("/C=CN/ST=shanghai/L=huawei/O=www.test.com/OU=test/CN=www.test.com/emailAddress=test@test.com", (char *)out.data); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); + HcfObjDestroy(crlEntry); HcfFree(out.data); } @@ -1035,9 +1042,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest143, TestSize.Level0) EXPECT_NE(encodingBlob.data, nullptr); HcfFree(encodingBlob.data); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); + HcfObjDestroy(crlEntry); } // Test crl getRevokedCertWithCert false @@ -1058,7 +1065,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest144, TestSize.Level0) EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(crlEntry, nullptr); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Crl); } // Test crl getRevokedCertWithCert false @@ -1089,8 +1096,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest145, TestSize.Level0) EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(crlEntry, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); } // Test crl getRevokedCertWithCert false @@ -1119,8 +1126,8 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest146, TestSize.Level0) ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, nullptr); EXPECT_NE(ret, HCF_SUCCESS); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); } // Test crl getRevokedCertWithCert false @@ -1156,9 +1163,9 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest147, TestSize.Level0) EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(out.data, nullptr); - OH_HCF_OBJ_DESTROY(x509Cert); - OH_HCF_OBJ_DESTROY(x509Crl); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(x509Cert); + HcfObjDestroy(x509Crl); + HcfObjDestroy(crlEntry); } // Test crl entry getRevokedCerts true @@ -1169,7 +1176,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest151, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(entrysOut.data, nullptr); - HcfX509CrlEntry *crlEntry = (HcfX509CrlEntry *)(entrysOut.data[0].data); + HcfX509CrlEntry *crlEntry = reinterpret_cast(entrysOut.data[0].data); HcfBlob out = { 0 }; ret = crlEntry->getRevocationDate(crlEntry, &out); EXPECT_EQ(ret, HCF_SUCCESS); @@ -1177,7 +1184,7 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest151, TestSize.Level0) EXPECT_STREQ((char *)g_rvTime->data, (char *)out.data); HcfFree(out.data); - OH_HCF_OBJ_DESTROY(crlEntry); + HcfObjDestroy(crlEntry); } // Test crl entry getRevokedCerts false @@ -1373,4 +1380,184 @@ HWTEST_F(CryptoX509CrlTest, X509CrlTest204, TestSize.Level0) HcfResult ret = g_x509Crl->getSignatureAlgParams(nullptr, nullptr); EXPECT_NE(ret, HCF_SUCCESS); } + +HWTEST_F(CryptoX509CrlTest, NullSpi, TestSize.Level0) +{ + (void)HcfCX509CrlSpiCreate(nullptr, nullptr); + (void)HcfCX509CRLEntryCreate(nullptr, nullptr, nullptr); + HcfX509CrlSpi *spiObj = nullptr; + HcfResult ret = HcfCX509CrlSpiCreate(g_crlDerInStream, &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + + (void)spiObj->base.destroy(nullptr); + const char *tmp = spiObj->engineGetType(nullptr); + EXPECT_EQ(tmp, nullptr); + bool flag = spiObj->engineIsRevoked(nullptr, nullptr); + EXPECT_EQ(flag, false); + ret = spiObj->engineGetEncoded(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineVerify(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + long ver = spiObj->engineGetVersion(nullptr); + EXPECT_EQ(ver, -1); + ret = spiObj->engineGetIssuerName(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetLastUpdate(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetNextUpdate(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetRevokedCert(nullptr, 0, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetRevokedCertWithCert(nullptr, nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetRevokedCerts(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetTbsInfo(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignature(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgName(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgOid(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgParams(nullptr, nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +static const char *GetInvalidCrlClass(void) +{ + return "INVALID_CRL_CLASS"; +} + +HWTEST_F(CryptoX509CrlTest, InvalidCrlSpiClass, TestSize.Level0) +{ + HcfX509CrlSpi invalidSpi = { {0} }; + invalidSpi.base.getClass = GetInvalidCrlClass; + HcfBlob invalidOut = { 0 }; + HcfEncodingBlob encoding = { 0 }; + HcfX509CrlEntry *entry = nullptr; + HcfX509CrlSpi *spiObj = nullptr; + HcfResult ret = HcfCX509CrlSpiCreate(g_crlDerInStream, &spiObj); + (void)spiObj->base.destroy(&(invalidSpi.base)); + const char *tmp = spiObj->engineGetType(&invalidSpi); + EXPECT_EQ(tmp, nullptr); + HcfCertificate cert; + bool flag = spiObj->engineIsRevoked(&invalidSpi, &cert); + EXPECT_EQ(flag, false); + ret = spiObj->engineGetEncoded(&invalidSpi, &encoding); + EXPECT_NE(ret, HCF_SUCCESS); + HcfPubKey pubKey; + ret = spiObj->engineVerify(&invalidSpi, &pubKey); + EXPECT_NE(ret, HCF_SUCCESS); + long ver = spiObj->engineGetVersion(&invalidSpi); + EXPECT_EQ(ver, -1); + ret = spiObj->engineGetIssuerName(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetLastUpdate(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetNextUpdate(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetRevokedCert(&invalidSpi, 0, &entry); + EXPECT_NE(ret, HCF_SUCCESS); + HcfX509Certificate x509Cert; + ret = spiObj->engineGetRevokedCertWithCert(&invalidSpi, &x509Cert, &entry); + EXPECT_NE(ret, HCF_SUCCESS); + HcfArray invalidArr = { 0 }; + ret = spiObj->engineGetRevokedCerts(&invalidSpi, &invalidArr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetTbsInfo(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignature(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgName(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgOid(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineGetSignatureAlgParams(&invalidSpi, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoX509CrlTest, InvalidCrlClass, TestSize.Level0) +{ + HcfX509Crl invalidCrl; + invalidCrl.base.base.getClass = GetInvalidCrlClass; + HcfBlob invalidOut = { 0 }; + HcfEncodingBlob encoding = { 0 }; + HcfX509CrlEntry *entry = nullptr; + + g_x509Crl->base.base.destroy(nullptr); + g_x509Crl->base.base.destroy(&(invalidCrl.base.base)); + const char *tmp = g_x509Crl->base.getType(&(invalidCrl.base)); + EXPECT_EQ(tmp, nullptr); + HcfCertificate cert; + bool flag = g_x509Crl->base.isRevoked(&(invalidCrl.base), &cert); + EXPECT_EQ(flag, false); + HcfResult ret = g_x509Crl->getEncoded(&invalidCrl, &encoding); + EXPECT_NE(ret, HCF_SUCCESS); + HcfPubKey pubKey; + ret = g_x509Crl->verify(&invalidCrl, &pubKey); + EXPECT_NE(ret, HCF_SUCCESS); + long ver = g_x509Crl->getVersion(&invalidCrl); + EXPECT_EQ(ver, -1); + ret = g_x509Crl->getIssuerName(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getLastUpdate(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getNextUpdate(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getRevokedCert(&invalidCrl, 0, &entry); + EXPECT_NE(ret, HCF_SUCCESS); + HcfX509Certificate x509Cert; + ret = g_x509Crl->getRevokedCertWithCert(&invalidCrl, &x509Cert, &entry); + EXPECT_NE(ret, HCF_SUCCESS); + HcfArray invalidArr = { 0 }; + ret = g_x509Crl->getRevokedCerts(&invalidCrl, &invalidArr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getTbsInfo(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignature(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgName(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgOid(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgParams(&invalidCrl, &invalidOut); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoX509CrlTest, InvalidMalloc, TestSize.Level0) +{ + SetMockFlag(true); + HcfBlob out = { 0 }; + HcfEncodingBlob encoding = { 0 }; + HcfX509CrlEntry *entry = nullptr; + HcfResult ret = g_x509Crl->getEncoded(g_x509Crl, &encoding); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getIssuerName(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getLastUpdate(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getNextUpdate(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getRevokedCert(g_x509Crl, 0, &entry); + EXPECT_NE(ret, HCF_SUCCESS); + HcfArray arr = { 0 }; + ret = g_x509Crl->getRevokedCerts(g_x509Crl, &arr); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getTbsInfo(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignature(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgName(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, &out); + EXPECT_NE(ret, HCF_SUCCESS); + SetMockFlag(false); +} } \ No newline at end of file diff --git a/test/unittest/src/memory_mock.c b/test/unittest/src/memory_mock.c new file mode 100755 index 0000000000000000000000000000000000000000..35f7b2c6c6ec1cd20e143066c3bc11ca86dc141c --- /dev/null +++ b/test/unittest/src/memory_mock.c @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2022 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 "memory.h" +#include "memory_mock.h" + +#include "log.h" +#include "securec.h" + +static bool g_isMock = false; +static uint32_t g_mallocMockIndex = __INT32_MAX__; +static uint32_t g_mallocNum = 0; +static bool g_isRecordMallocNum = false; + +void SetMockFlag(bool flag) +{ + g_isMock = flag; +} + +void *HcfMalloc(uint32_t size, char val) +{ + if (g_isMock) { + return NULL; + } + if (g_isRecordMallocNum) { + if (g_mallocNum == g_mallocMockIndex) { + LOGI("mock malloc return NULL."); + return NULL; + } + g_mallocNum++; + } + void *addr = malloc(size); + if (addr != NULL) { + (void)memset_s(addr, size, val, size); + } + return addr; +} + +void HcfFree(void *addr) +{ + if (addr != NULL) { + free(addr); + } +} + +void StartRecordMallocNum(void) +{ + ResetRecordMallocNum(); + g_isRecordMallocNum = true; +} + +void EndRecordMallocNum(void) +{ + ResetRecordMallocNum(); + g_isRecordMallocNum = false; +} + +uint32_t GetMallocNum(void) +{ + return g_mallocNum; +} + +void ResetRecordMallocNum(void) +{ + g_mallocNum = 0; + g_mallocMockIndex = __INT32_MAX__; +} + +void SetMockMallocIndex(uint32_t index) +{ + g_mallocMockIndex = index; +} \ No newline at end of file diff --git a/test/unittest/src/openssl_adapter_mock.c b/test/unittest/src/openssl_adapter_mock.c new file mode 100644 index 0000000000000000000000000000000000000000..e813a9d42a714b04910aa8208e9d2fc39c28fef8 --- /dev/null +++ b/test/unittest/src/openssl_adapter_mock.c @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_adapter.h" +#include "openssl_adapter_mock.h" + +#include "log.h" +#include "result.h" + +static uint32_t g_mockIndex = __INT32_MAX__; +static uint32_t g_callNum = 0; +static bool g_isRecordCallNum = false; +static bool g_isNeedSpecialMock = false; + +static bool Is_Need_Mock(void) +{ + if (!g_isRecordCallNum) { + return false; + } + g_callNum++; + if (g_callNum == g_mockIndex) { + LOGI("mock malloc return NULL."); + return true; + } + return false; +} + +void StartRecordOpensslCallNum(void) +{ + ResetOpensslCallNum(); + g_isRecordCallNum = true; +} + +void EndRecordOpensslCallNum(void) +{ + ResetOpensslCallNum(); + g_isRecordCallNum = false; +} + +uint32_t GetOpensslCallNum(void) +{ + return g_callNum; +} + +void ResetOpensslCallNum(void) +{ + g_callNum = 0; + g_mockIndex = __INT32_MAX__; +} + +void SetOpensslCallMockIndex(uint32_t index) +{ + g_mockIndex = index; +} + +BIGNUM *Openssl_BN_dup(const BIGNUM *a) +{ + if (Is_Need_Mock()) { + return NULL; + } + return BN_dup(a); +} + +void Openssl_BN_clear(BIGNUM *a) +{ + BN_clear(a); +} + +void Openssl_BN_clear_free(BIGNUM *a) +{ + BN_clear_free(a); +} + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_new_by_curve_name(nid); +} + +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_POINT_dup(src, group); +} + +int Openssl_EC_KEY_generate_key(EC_KEY *eckey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_generate_key(eckey); +} + +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_set_public_key(key, pub); +} + +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_set_private_key(key, priv_key); +} + +int Openssl_EC_KEY_check_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_check_key(key); +} + +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_public_key(key); +} + +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_private_key(key); +} + +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_group(key); +} + +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp) +{ + if (Is_Need_Mock()) { + return -1; + } + return i2d_EC_PUBKEY(a, pp); +} + +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out) +{ + if (Is_Need_Mock()) { + return -1; + } + return i2d_ECPrivateKey(key, out); +} + +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) +{ + if (Is_Need_Mock()) { + return NULL; + } + return d2i_EC_PUBKEY(a, pp, length); +} + +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len) +{ + if (Is_Need_Mock()) { + return NULL; + } + return d2i_ECPrivateKey(key, in, len); +} + +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag) +{ + EC_KEY_set_asn1_flag(key, flag); +} + +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags) +{ + EC_KEY_set_enc_flags(eckey, flags); +} + +void Openssl_EC_KEY_free(EC_KEY *key) +{ + EC_KEY_free(key); +} + +void Openssl_EC_POINT_free(EC_POINT *point) +{ + EC_POINT_free(point); +} + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_MD_CTX_new(); +} + +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx) +{ + EVP_MD_CTX_free(ctx); +} + +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestSignInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestSignUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen) +{ + if (sigret != NULL && g_isNeedSpecialMock) { + g_callNum++; + } + if (Is_Need_Mock()) { + if (sigret == NULL) { + return -1; + } + if (g_isNeedSpecialMock) { + int res = EVP_DigestSignFinal(ctx, sigret, siglen); + *siglen = *siglen * 2; + g_isNeedSpecialMock = false; + return res; + } + g_isNeedSpecialMock = true; + return -1; + } + if (sigret != NULL) { + g_callNum++; + } + return EVP_DigestSignFinal(ctx, sigret, siglen); +} + +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyFinal(ctx, sig, siglen); +} + +EVP_PKEY *Openssl_EVP_PKEY_new(void) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_PKEY_new(); +} + +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_assign_EC_KEY(pkey, key); +} + +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey) +{ + EVP_PKEY_free(pkey); +} + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_PKEY_CTX_new(pkey, e); +} + +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_derive_init(ctx); +} + +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_derive_set_peer(ctx, peer); +} + +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen) +{ + if (key != NULL && g_isNeedSpecialMock) { + g_callNum++; + } + if (Is_Need_Mock()) { + if (key == NULL) { + return -1; + } + if (g_isNeedSpecialMock) { + int res = EVP_PKEY_derive(ctx, key, keylen); + *keylen = *keylen * 2; + g_isNeedSpecialMock = false; + return res; + } + g_isNeedSpecialMock = true; + return -1; + } + if (key != NULL) { + g_callNum++; + } + return EVP_PKEY_derive(ctx, key, keylen); +} + +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) +{ + EVP_PKEY_CTX_free(ctx); +}