From 4b5d26c6353f7339d6f32571e1df8c168fe02a84 Mon Sep 17 00:00:00 2001 From: wangyongzhong2 Date: Wed, 15 Nov 2023 14:17:01 +0800 Subject: [PATCH 1/2] =?UTF-8?q?add=20BrainPool=E3=80=81sm2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangyongzhong2 --- BUILD.gn | 1 + common/inc/params_parser.h | 29 +- common/inc/utils.h | 1 + common/src/asy_key_params.c | 5 +- common/src/params_parser.c | 57 +- common/src/utils.c | 11 + frameworks/crypto_operation/cipher.c | 3 +- frameworks/crypto_operation/key_agreement.c | 15 + frameworks/crypto_operation/signature.c | 69 +- frameworks/frameworks.gni | 2 + frameworks/js/napi/crypto/BUILD.gn | 1 + .../inc/napi_crypto_framework_defines.h | 1 + .../js/napi/crypto/inc/napi_ecc_key_util.h | 39 + frameworks/js/napi/crypto/inc/napi_utils.h | 10 +- .../js/napi/crypto/src/napi_ecc_key_util.cpp | 89 + frameworks/js/napi/crypto/src/napi_init.cpp | 4 + frameworks/js/napi/crypto/src/napi_sign.cpp | 90 +- frameworks/js/napi/crypto/src/napi_utils.cpp | 290 +- frameworks/js/napi/crypto/src/napi_verify.cpp | 89 +- frameworks/key/asy_key_generator.c | 149 +- frameworks/key/ecc_key_util.c | 88 + frameworks/key/key_utils.c | 160 + frameworks/spi/ecc_key_util_spi.h | 29 + frameworks/spi/signature_spi.h | 4 + interfaces/innerkits/common/result.h | 2 +- .../innerkits/crypto_operation/cipher.h | 3 +- .../innerkits/crypto_operation/signature.h | 5 + interfaces/innerkits/key/ecc_key_util.h | 33 + interfaces/innerkits/key/key_utils.h | 41 + .../common/inc/ecc_openssl_common.h | 412 +++ .../common/inc/openssl_adapter.h | 4 + .../openssl_plugin/common/inc/openssl_class.h | 4 + .../common/inc/openssl_common.h | 4 + .../common/src/openssl_adapter.c | 15 + .../common/src/openssl_common.c | 196 +- .../cipher/src/cipher_3des_openssl.c | 27 + .../cipher/src/cipher_aes_openssl.c | 27 + .../cipher/src/cipher_sm2_openssl.c | 37 + .../cipher/src/cipher_sm4_openssl.c | 27 + .../signature/src/dsa_openssl.c | 18 + .../signature/src/ecdsa_openssl.c | 106 +- .../signature/src/signature_rsa_openssl.c | 20 +- .../signature/src/sm2_openssl.c | 323 +- .../ecc_common_param_spec_generator_openssl.h | 32 + .../src/ecc_asy_key_generator_openssl.c | 559 ++- .../ecc_common_param_spec_generator_openssl.c | 259 ++ .../src/sm2_asy_key_generator_openssl.c | 1119 +++++- plugin/plugin.gni | 1 + .../hcfsigncreate_fuzzer.cpp | 64 + .../hcfverifycreate_fuzzer.cpp | 100 + .../asykeygenerator_fuzzer.cpp | 326 +- test/fuzztest/key/ecckeyutil_fuzzer/BUILD.gn | 56 + .../key/ecckeyutil_fuzzer/corpus/init | 14 + .../ecckeyutil_fuzzer/ecckeyutil_fuzzer.cpp | 86 + .../key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.h | 21 + .../key/ecckeyutil_fuzzer/project.xml | 25 + test/unittest/BUILD.gn | 7 + ...rypto_brainpool_asy_key_generator_test.cpp | 2090 +++++++++++ .../crypto_brainpool_key_agreement_test.cpp | 423 +++ .../crypto_brainpool_no_length_sign_test.cpp | 983 ++++++ ...crypto_brainpool_no_length_verify_test.cpp | 1337 +++++++ ...pto_ecc_asy_key_generator_by_spec_test.cpp | 444 +++ .../unittest/src/crypto_ecc_key_util_test.cpp | 1947 +++++++++++ ...pto_sm2_asy_key_generator_by_spec_test.cpp | 3097 +++++++++++++++++ test/unittest/src/crypto_sm2_cipher_test.cpp | 328 ++ test/unittest/src/crypto_sm2_sign_test.cpp | 376 +- test/unittest/src/crypto_sm2_verify_test.cpp | 406 ++- 67 files changed, 16207 insertions(+), 433 deletions(-) create mode 100644 frameworks/js/napi/crypto/inc/napi_ecc_key_util.h create mode 100644 frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp create mode 100644 frameworks/key/ecc_key_util.c create mode 100644 frameworks/key/key_utils.c create mode 100644 frameworks/spi/ecc_key_util_spi.h create mode 100644 interfaces/innerkits/key/ecc_key_util.h create mode 100644 interfaces/innerkits/key/key_utils.h create mode 100644 plugin/openssl_plugin/key/asy_key_generator/inc/ecc_common_param_spec_generator_openssl.h create mode 100644 plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c create mode 100644 test/fuzztest/key/ecckeyutil_fuzzer/BUILD.gn create mode 100644 test/fuzztest/key/ecckeyutil_fuzzer/corpus/init create mode 100644 test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.cpp create mode 100644 test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.h create mode 100644 test/fuzztest/key/ecckeyutil_fuzzer/project.xml create mode 100644 test/unittest/src/crypto_brainpool_asy_key_generator_test.cpp create mode 100644 test/unittest/src/crypto_brainpool_key_agreement_test.cpp create mode 100644 test/unittest/src/crypto_brainpool_no_length_sign_test.cpp create mode 100644 test/unittest/src/crypto_brainpool_no_length_verify_test.cpp create mode 100644 test/unittest/src/crypto_ecc_key_util_test.cpp create mode 100644 test/unittest/src/crypto_sm2_asy_key_generator_by_spec_test.cpp diff --git a/BUILD.gn b/BUILD.gn index 6950b52..8234646 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -40,6 +40,7 @@ group("crypto_framework_fuzztest") { "test/fuzztest/crypto_operation/hcfsigncreate_fuzzer:fuzztest", "test/fuzztest/crypto_operation/hcfverifycreate_fuzzer:fuzztest", "test/fuzztest/key/asykeygenerator_fuzzer:fuzztest", + "test/fuzztest/key/ecckeyutil_fuzzer:fuzztest", "test/fuzztest/key/symkeygenerator_fuzzer:fuzztest", "test/fuzztest/rand/hcfrandcreate_fuzzer:fuzztest", ] diff --git a/common/inc/params_parser.h b/common/inc/params_parser.h index 6b38938..9a984a4 100644 --- a/common/inc/params_parser.h +++ b/common/inc/params_parser.h @@ -40,6 +40,7 @@ typedef enum { HCF_ALG_SM4, HCF_ALG_HMAC, HCF_ALG_PKBDF2, + HCF_ALG_ECC_BRAINPOOL, } HcfAlgValue; typedef enum { @@ -118,6 +119,7 @@ typedef enum { HCF_ALG_SM4_DEFAULT, HCF_ALG_3DES_DEFAULT, HCF_ALG_HMAC_DEFAULT, + HCF_ALG_ECC_BRAINPOOL_DEFAULT, // key derivation function, PBKDF2 HCF_ALG_PBKDF2_DEFAULT, @@ -125,19 +127,40 @@ typedef enum { // sm2 text format HCF_ALG_TEXT_FORMAT_C1C3C2, HCF_ALG_TEXT_FORMAT_C1C2C3, + + // brainpool + HCF_ALG_ECC_BP160R1, + HCF_ALG_ECC_BP160T1, + HCF_ALG_ECC_BP192R1, + HCF_ALG_ECC_BP192T1, + HCF_ALG_ECC_BP224R1, + HCF_ALG_ECC_BP224T1, + HCF_ALG_ECC_BP256R1, + HCF_ALG_ECC_BP256T1, + HCF_ALG_ECC_BP320R1, + HCF_ALG_ECC_BP320T1, + HCF_ALG_ECC_BP384R1, + HCF_ALG_ECC_BP384T1, + HCF_ALG_ECC_BP512R1, + HCF_ALG_ECC_BP512T1, } HcfAlgParaValue; typedef struct { - const char* tag; + const char *tag; HcfAlgParaType paraType; HcfAlgParaValue paraValue; } HcfParaConfig; typedef struct { - const char* algNameStr; + const char *algNameStr; HcfAlgValue algValue; } HcfAlgMap; +typedef struct { + const char *curveNameStr; + HcfAlgParaValue algValue; +} HcfCurveMap; + typedef struct { HcfAlgValue algo; HcfAlgParaValue keySize; @@ -179,6 +202,8 @@ HcfResult ParseAndSetParameter(const char *paramsStr, void *params, SetParameter HcfResult ParseAlgNameToParams(const char *algNameStr, HcfAsyKeyGenParams *params); +HcfResult ParseCurveNameToParams(const char *curveNameStr, HcfAsyKeyGenParams *params); + #ifdef __cplusplus } #endif diff --git a/common/inc/utils.h b/common/inc/utils.h index 3aae360..3bacbc2 100644 --- a/common/inc/utils.h +++ b/common/inc/utils.h @@ -28,6 +28,7 @@ extern "C" { bool IsStrValid(const char *str, uint32_t maxLen); bool IsBlobValid(const HcfBlob *blob); bool IsClassMatch(const HcfObjectBase *obj, const char *className); +size_t HcfStrlen(const char *str); #ifdef __cplusplus } diff --git a/common/src/asy_key_params.c b/common/src/asy_key_params.c index 2de7d28..65b8252 100644 --- a/common/src/asy_key_params.c +++ b/common/src/asy_key_params.c @@ -18,7 +18,7 @@ #include #include #include - +#include "params_parser.h" #include "big_integer.h" #include "detailed_dsa_key_params.h" #include "detailed_ecc_key_params.h" @@ -28,6 +28,7 @@ #define ALG_NAME_DSA "DSA" #define ALG_NAME_ECC "ECC" +#define ALG_NAME_SM2 "SM2" #define ALG_NAME_RSA "RSA" void FreeDsaCommParamsSpec(HcfDsaCommParamsSpec *spec) @@ -259,7 +260,7 @@ void FreeAsyKeySpec(HcfAsyKeyParamsSpec *spec) } if (strcmp(spec->algName, ALG_NAME_DSA) == 0) { return DestroyDsaParamsSpec(spec); - } else if (strcmp(spec->algName, ALG_NAME_ECC) == 0) { + } else if (strcmp(spec->algName, ALG_NAME_ECC) == 0 || strcmp(spec->algName, ALG_NAME_SM2) == 0) { return DestroyEccParamsSpec(spec); } else if (strcmp(spec->algName, ALG_NAME_RSA) == 0) { return DestroyRsaParamsSpec(spec); diff --git a/common/src/params_parser.c b/common/src/params_parser.c index d13802f..efda7ae 100644 --- a/common/src/params_parser.c +++ b/common/src/params_parser.c @@ -97,16 +97,54 @@ static const HcfParaConfig PARAM_CONFIG[] = { {"3DES", HCF_ALG_TYPE, HCF_ALG_3DES_DEFAULT}, {"HMAC", HCF_ALG_TYPE, HCF_ALG_HMAC_DEFAULT}, {"PBKDF2", HCF_ALG_TYPE, HCF_ALG_PBKDF2_DEFAULT}, + {"ECC_BP", HCF_ALG_TYPE, HCF_ALG_ECC_BRAINPOOL_DEFAULT}, {"C1C3C2", HCF_ALG_TEXT_FORMAT, HCF_ALG_TEXT_FORMAT_C1C3C2}, {"C1C2C3", HCF_ALG_TEXT_FORMAT, HCF_ALG_TEXT_FORMAT_C1C2C3}, + + {"ECC_BrainPoolP160r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP160R1}, + {"ECC_BrainPoolP160t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP160T1}, + {"ECC_BrainPoolP192r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP192R1}, + {"ECC_BrainPoolP192t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP192T1}, + {"ECC_BrainPoolP224r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP224R1}, + {"ECC_BrainPoolP224t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP224T1}, + {"ECC_BrainPoolP256r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP256R1}, + {"ECC_BrainPoolP256t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP256T1}, + {"ECC_BrainPoolP320r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP320R1}, + {"ECC_BrainPoolP320t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP320T1}, + {"ECC_BrainPoolP384r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP384R1}, + {"ECC_BrainPoolP384t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP384T1}, + {"ECC_BrainPoolP512r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512R1}, + {"ECC_BrainPoolP512t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512T1} }; static const HcfAlgMap ALG_MAP[] = { {"DSA", HCF_ALG_DSA}, {"RSA", HCF_ALG_RSA}, {"ECC", HCF_ALG_ECC}, - {"SM2", HCF_ALG_SM2}, + {"SM2", HCF_ALG_SM2} +}; + +static const HcfCurveMap CURVE_MAP[] = { + {"NID_secp224r1", HCF_ALG_ECC_224}, + {"NID_X9_62_prime256v1", HCF_ALG_ECC_256}, + {"NID_secp384r1", HCF_ALG_ECC_384}, + {"NID_secp521r1", HCF_ALG_ECC_521}, + {"NID_sm2", HCF_ALG_SM2_256}, + {"NID_brainpoolP160r1", HCF_ALG_ECC_BP160R1}, + {"NID_brainpoolP160t1", HCF_ALG_ECC_BP160T1}, + {"NID_brainpoolP192r1", HCF_ALG_ECC_BP192R1}, + {"NID_brainpoolP192t1", HCF_ALG_ECC_BP192T1}, + {"NID_brainpoolP224r1", HCF_ALG_ECC_BP224R1}, + {"NID_brainpoolP224t1", HCF_ALG_ECC_BP224T1}, + {"NID_brainpoolP256r1", HCF_ALG_ECC_BP256R1}, + {"NID_brainpoolP256t1", HCF_ALG_ECC_BP256T1}, + {"NID_brainpoolP320r1", HCF_ALG_ECC_BP320R1}, + {"NID_brainpoolP320t1", HCF_ALG_ECC_BP320T1}, + {"NID_brainpoolP384r1", HCF_ALG_ECC_BP384R1}, + {"NID_brainpoolP384t1", HCF_ALG_ECC_BP384T1}, + {"NID_brainpoolP512r1", HCF_ALG_ECC_BP512R1}, + {"NID_brainpoolP512t1", HCF_ALG_ECC_BP512T1} }; static const HcfParaConfig *FindConfig(const HcString* tag) @@ -183,3 +221,20 @@ HcfResult ParseAlgNameToParams(const char *algNameStr, HcfAsyKeyGenParams *param LOGE("Not support algorithm name: %s", algNameStr); return HCF_INVALID_PARAMS; } + +HcfResult ParseCurveNameToParams(const char *curveNameStr, HcfAsyKeyGenParams *params) +{ + if (curveNameStr == NULL || params == NULL) { + LOGE("curveName to Params failed!"); + return HCF_INVALID_PARAMS; + } + for (uint32_t i = 0; i < sizeof(CURVE_MAP) / sizeof(HcfAlgMap); ++i) { + if (strcmp(curveNameStr, CURVE_MAP[i].curveNameStr) == 0) { + params->algo = HCF_ALG_ECC; + params->bits = CURVE_MAP[i].algValue; + return HCF_SUCCESS; + } + } + LOGE("Not support algorithm name: %s", curveNameStr); + return HCF_NOT_SUPPORT; +} diff --git a/common/src/utils.c b/common/src/utils.c index a66cbce..9b648b0 100644 --- a/common/src/utils.c +++ b/common/src/utils.c @@ -18,6 +18,8 @@ #include #include "log.h" +#define ERROR_STR_LENGTH 0 + bool IsStrValid(const char *str, uint32_t maxLen) { if (str == NULL) { @@ -49,3 +51,12 @@ bool IsClassMatch(const HcfObjectBase *obj, const char *className) return false; } } + +size_t HcfStrlen(const char *str) +{ + if (str == NULL) { + LOGE("str is null"); + return ERROR_STR_LENGTH; + } + return strlen(str); +} diff --git a/frameworks/crypto_operation/cipher.c b/frameworks/crypto_operation/cipher.c index 5e7f823..b9dcc59 100644 --- a/frameworks/crypto_operation/cipher.c +++ b/frameworks/crypto_operation/cipher.c @@ -232,7 +232,8 @@ static HcfResult SetCipherSpecUint8Array(HcfCipher *self, CipherSpecItem item, H static bool CheckCipherSpecString(CipherSpecItem item) { - return item == OAEP_MD_NAME_STR || item == OAEP_MGF_NAME_STR || item == OAEP_MGF1_MD_STR; + return ((item == OAEP_MD_NAME_STR) || (item == OAEP_MGF_NAME_STR) || + (item == OAEP_MGF1_MD_STR) || (item == SM2_MD_NAME_STR)); } static HcfResult GetCipherSpecString(HcfCipher *self, CipherSpecItem item, char **returnString) diff --git a/frameworks/crypto_operation/key_agreement.c b/frameworks/crypto_operation/key_agreement.c index 979875c..db9405c 100644 --- a/frameworks/crypto_operation/key_agreement.c +++ b/frameworks/crypto_operation/key_agreement.c @@ -63,9 +63,24 @@ static void SetKeyType(HcfAlgParaValue value, HcfKeyAgreementParams *paramsObj) case HCF_ALG_ECC_256: case HCF_ALG_ECC_384: case HCF_ALG_ECC_521: + case HCF_ALG_ECC_BP160R1: + case HCF_ALG_ECC_BP160T1: + case HCF_ALG_ECC_BP192R1: + case HCF_ALG_ECC_BP192T1: + case HCF_ALG_ECC_BP224R1: + case HCF_ALG_ECC_BP224T1: + case HCF_ALG_ECC_BP256R1: + case HCF_ALG_ECC_BP256T1: + case HCF_ALG_ECC_BP320R1: + case HCF_ALG_ECC_BP320T1: + case HCF_ALG_ECC_BP384R1: + case HCF_ALG_ECC_BP384T1: + case HCF_ALG_ECC_BP512R1: + case HCF_ALG_ECC_BP512T1: paramsObj->algo = HCF_ALG_ECC; break; default: + LOGE("Invalid algo %u.", value); break; } } diff --git a/frameworks/crypto_operation/signature.c b/frameworks/crypto_operation/signature.c index f4ed9f5..cb3f1e5 100644 --- a/frameworks/crypto_operation/signature.c +++ b/frameworks/crypto_operation/signature.c @@ -63,14 +63,16 @@ static const HcfSignGenAbility SIGN_GEN_ABILITY_SET[] = { { HCF_ALG_ECC, HcfSignSpiEcdsaCreate }, { HCF_ALG_RSA, HcfSignSpiRsaCreate }, { HCF_ALG_DSA, HcfSignSpiDsaCreate }, - { HCF_ALG_SM2, HcfSignSpiSm2Create } + { HCF_ALG_SM2, HcfSignSpiSm2Create }, + { HCF_ALG_ECC_BRAINPOOL, HcfSignSpiEcdsaCreate }, }; static const HcfVerifyGenAbility VERIFY_GEN_ABILITY_SET[] = { { HCF_ALG_ECC, HcfVerifySpiEcdsaCreate }, { HCF_ALG_RSA, HcfVerifySpiRsaCreate }, { HCF_ALG_DSA, HcfVerifySpiDsaCreate }, - { HCF_ALG_SM2, HcfVerifySpiSm2Create } + { HCF_ALG_SM2, HcfVerifySpiSm2Create }, + { HCF_ALG_ECC_BRAINPOOL, HcfVerifySpiEcdsaCreate }, }; static HcfSignSpiCreateFunc FindSignAbility(HcfSignatureParams *params) @@ -110,6 +112,9 @@ static void SetKeyTypeDefault(HcfAlgParaValue value, HcfSignatureParams *params case HCF_ALG_SM2_DEFAULT: paramsObj->algo = HCF_ALG_SM2; break; + case HCF_ALG_ECC_BRAINPOOL_DEFAULT: + paramsObj->algo = HCF_ALG_ECC_BRAINPOOL; + break; default: LOGE("Invalid algo %u.", value); break; @@ -125,6 +130,22 @@ static void SetKeyType(HcfAlgParaValue value, HcfSignatureParams *paramsObj) case HCF_ALG_ECC_521: paramsObj->algo = HCF_ALG_ECC; break; + case HCF_ALG_ECC_BP160R1: + case HCF_ALG_ECC_BP160T1: + case HCF_ALG_ECC_BP192R1: + case HCF_ALG_ECC_BP192T1: + case HCF_ALG_ECC_BP224R1: + case HCF_ALG_ECC_BP224T1: + case HCF_ALG_ECC_BP256R1: + case HCF_ALG_ECC_BP256T1: + case HCF_ALG_ECC_BP320R1: + case HCF_ALG_ECC_BP320T1: + case HCF_ALG_ECC_BP384R1: + case HCF_ALG_ECC_BP384T1: + case HCF_ALG_ECC_BP512R1: + case HCF_ALG_ECC_BP512T1: + paramsObj->algo = HCF_ALG_ECC_BRAINPOOL; + break; case HCF_OPENSSL_RSA_512: case HCF_OPENSSL_RSA_768: case HCF_OPENSSL_RSA_1024: @@ -220,6 +241,7 @@ static void DestroySign(HcfObjectBase *self) return; } if (!IsClassMatch(self, GetSignClass())) { + LOGE("Class not match."); return; } HcfSignImpl *impl = (HcfSignImpl *)self; @@ -234,6 +256,7 @@ static void DestroyVerify(HcfObjectBase *self) return; } if (!IsClassMatch(self, GetVerifyClass())) { + LOGE("Class not match."); return; } HcfVerifyImpl *impl = (HcfVerifyImpl *)self; @@ -249,6 +272,7 @@ static HcfResult SetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t saltLe return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfSignImpl *tmpSelf = (HcfSignImpl *)self; @@ -262,12 +286,27 @@ static HcfResult GetSignSpecString(HcfSign *self, SignSpecItem item, char **retu return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfSignImpl *tmpSelf = (HcfSignImpl *)self; return tmpSelf->spiObj->engineGetSignSpecString(tmpSelf->spiObj, item, returnString); } +static HcfResult SetSignSpecUint8Array(HcfSign *self, SignSpecItem item, HcfBlob blob) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + HcfSignImpl *tmpSelf = (HcfSignImpl *)self; + return tmpSelf->spiObj->engineSetSignSpecUint8Array(tmpSelf->spiObj, item, blob); +} + static HcfResult GetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t *returnInt) { if (self == NULL || returnInt == NULL) { @@ -275,6 +314,7 @@ static HcfResult GetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t *retur return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfSignImpl *tmpSelf = (HcfSignImpl *)self; @@ -289,6 +329,7 @@ static HcfResult SignInit(HcfSign *self, HcfParamsSpec *params, HcfPriKey *priva } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } return ((HcfSignImpl *)self)->spiObj->engineInit(((HcfSignImpl *)self)->spiObj, params, privateKey); @@ -302,6 +343,7 @@ static HcfResult SignUpdate(HcfSign *self, HcfBlob *data) } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } return ((HcfSignImpl *)self)->spiObj->engineUpdate(((HcfSignImpl *)self)->spiObj, data); @@ -315,6 +357,7 @@ static HcfResult SignDoFinal(HcfSign *self, HcfBlob *data, HcfBlob *returnSignat } if (!IsClassMatch((HcfObjectBase *)self, GetSignClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } return ((HcfSignImpl *)self)->spiObj->engineSign(((HcfSignImpl *)self)->spiObj, data, returnSignatureData); @@ -327,6 +370,7 @@ static HcfResult SetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t sa return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self; @@ -340,12 +384,27 @@ static HcfResult GetVerifySpecString(HcfVerify *self, SignSpecItem item, char ** return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self; return tmpSelf->spiObj->engineGetVerifySpecString(tmpSelf->spiObj, item, returnString); } +static HcfResult SetVerifySpecUint8Array(HcfVerify *self, SignSpecItem item, HcfBlob blob) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self; + return tmpSelf->spiObj->engineSetVerifySpecUint8Array(tmpSelf->spiObj, item, blob); +} + static HcfResult GetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t *returnInt) { if (self == NULL || returnInt == NULL) { @@ -353,6 +412,7 @@ static HcfResult GetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t *r return HCF_INVALID_PARAMS; } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self; @@ -367,6 +427,7 @@ static HcfResult VerifyInit(HcfVerify *self, HcfParamsSpec *params, HcfPubKey *p } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } return ((HcfVerifyImpl *)self)->spiObj->engineInit(((HcfVerifyImpl *)self)->spiObj, params, publicKey); @@ -380,6 +441,7 @@ static HcfResult VerifyUpdate(HcfVerify *self, HcfBlob *data) } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return HCF_INVALID_PARAMS; } return ((HcfVerifyImpl *)self)->spiObj->engineUpdate(((HcfVerifyImpl *)self)->spiObj, data); @@ -392,6 +454,7 @@ static bool VerifyDoFinal(HcfVerify *self, HcfBlob *data, HcfBlob *signatureData return false; } if (!IsClassMatch((HcfObjectBase *)self, GetVerifyClass())) { + LOGE("Class not match."); return false; } return ((HcfVerifyImpl *)self)->spiObj->engineVerify(((HcfVerifyImpl *)self)->spiObj, data, signatureData); @@ -442,6 +505,7 @@ HcfResult HcfSignCreate(const char *algoName, HcfSign **returnObj) returnSign->base.setSignSpecInt = SetSignSpecInt; returnSign->base.getSignSpecInt = GetSignSpecInt; returnSign->base.getSignSpecString = GetSignSpecString; + returnSign->base.setSignSpecUint8Array = SetSignSpecUint8Array; returnSign->spiObj = spiObj; *returnObj = (HcfSign *)returnSign; @@ -492,6 +556,7 @@ HcfResult HcfVerifyCreate(const char *algoName, HcfVerify **returnObj) returnVerify->base.setVerifySpecInt = SetVerifySpecInt; returnVerify->base.getVerifySpecInt = GetVerifySpecInt; returnVerify->base.getVerifySpecString = GetVerifySpecString; + returnVerify->base.setVerifySpecUint8Array = SetVerifySpecUint8Array; returnVerify->spiObj = spiObj; *returnObj = (HcfVerify *)returnVerify; LOGD("HcfVerifyCreate end"); diff --git a/frameworks/frameworks.gni b/frameworks/frameworks.gni index ba90967..ad41b93 100644 --- a/frameworks/frameworks.gni +++ b/frameworks/frameworks.gni @@ -43,6 +43,8 @@ framework_key_agreement_files = framework_key_files = [ "${framework_path}/key/asy_key_generator.c", + "${framework_path}/key/ecc_key_util.c", + "${framework_path}/key/key_utils.c", "${framework_path}/key/sym_key_generator.c", ] diff --git a/frameworks/js/napi/crypto/BUILD.gn b/frameworks/js/napi/crypto/BUILD.gn index 286e9fc..a2ee368 100644 --- a/frameworks/js/napi/crypto/BUILD.gn +++ b/frameworks/js/napi/crypto/BUILD.gn @@ -46,6 +46,7 @@ ohos_shared_library("cryptoframework_napi") { "src/napi_asy_key_generator.cpp", "src/napi_asy_key_spec_generator.cpp", "src/napi_cipher.cpp", + "src/napi_ecc_key_util.cpp", "src/napi_init.cpp", "src/napi_kdf.cpp", "src/napi_key.cpp", diff --git a/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h b/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h index d86146e..151a57e 100644 --- a/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h +++ b/frameworks/js/napi/crypto/inc/napi_crypto_framework_defines.h @@ -62,6 +62,7 @@ const std::string CCM_PARAMS_SPEC = "CcmParamsSpec"; const std::string DSA_ASY_KEY_SPEC = "DSA"; const std::string ECC_ASY_KEY_SPEC = "ECC"; const std::string RSA_ASY_KEY_SPEC = "RSA"; +const std::string SM2_ASY_KEY_SPEC = "SM2"; const std::string TAG_SPEC_TYPE = "specType"; const std::string DSA_COMM_ASY_KEY_SPEC = "DsaCommParamsSpec"; const std::string DSA_PUB_ASY_KEY_SPEC = "DsaPubKeyParamsSpec"; diff --git a/frameworks/js/napi/crypto/inc/napi_ecc_key_util.h b/frameworks/js/napi/crypto/inc/napi_ecc_key_util.h new file mode 100644 index 0000000..71764e7 --- /dev/null +++ b/frameworks/js/napi/crypto/inc/napi_ecc_key_util.h @@ -0,0 +1,39 @@ +/* + * 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 HCF_NAPI_ECC_KEY_UTIL_H +#define HCF_NAPI_ECC_KEY_UTIL_H + +#include +#include "ecc_key_util.h" +#include "log.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace OHOS { +namespace CryptoFramework { +class NapiECCKeyUtil { +public: + explicit NapiECCKeyUtil(); + ~NapiECCKeyUtil(); + + static napi_value JsGenECCCommonParamsSpec(napi_env env, napi_callback_info info); + static napi_value ECCKeyUtilConstructor(napi_env env, napi_callback_info info); + static napi_value GenECCCommonParamSpec(napi_env env); + static void DefineNapiECCKeyUtilJSClass(napi_env env, napi_value exports); +}; +} // namespace CryptoFramework +} // namespace OHOS +#endif diff --git a/frameworks/js/napi/crypto/inc/napi_utils.h b/frameworks/js/napi/crypto/inc/napi_utils.h index 7eba368..19ce549 100644 --- a/frameworks/js/napi/crypto/inc/napi_utils.h +++ b/frameworks/js/napi/crypto/inc/napi_utils.h @@ -20,10 +20,11 @@ #include #include "algorithm_parameter.h" +#include "asy_key_params.h" #include "blob.h" #include "big_integer.h" #include "cipher.h" -#include "asy_key_params.h" +#include "detailed_ecc_key_params.h" #include "napi/native_api.h" #include "napi/native_node_api.h" #include "signature.h" @@ -56,7 +57,14 @@ napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob); napi_value ConvertCipherBlobToNapiValue(napi_env env, HcfBlob *blob); bool GetAsyKeySpecFromNapiValue(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec); +bool BuildSetNamedProperty(napi_env env, HcfBigInteger *number, const char *name, napi_value *intence); +bool BuildIntenceParterToNapiValue(napi_env env, HcfEccCommParamsSpec *blob, napi_value *intence); +bool CheckEccCommonParamSpec(napi_env env, HcfEccCommParamsSpec *blob); +napi_value ConvertEccCommonParamFieldFpToNapiValue(napi_env env, HcfEccCommParamsSpec *blob); +napi_value ConvertEccCommonParamPointToNapiValue(napi_env env, HcfEccCommParamsSpec *blob); napi_value ConvertBigIntToNapiValue(napi_env env, HcfBigInteger *blob); +napi_value ConvertEccCommParamsSpecToNapiValue(napi_env env, HcfEccCommParamsSpec *blob); + bool GetStringFromJSParams(napi_env env, napi_value arg, std::string &returnStr); bool GetInt32FromJSParams(napi_env env, napi_value arg, int32_t &returnInt); diff --git a/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp b/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp new file mode 100644 index 0000000..b8e26a1 --- /dev/null +++ b/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp @@ -0,0 +1,89 @@ +/* + * 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_ecc_key_util.h" +#include "securec.h" +#include "detailed_ecc_key_params.h" +#include "log.h" + +#include "napi_crypto_framework_defines.h" +#include "napi_utils.h" +#include "napi_key_pair.h" +#include "napi_pri_key.h" +#include "napi_pub_key.h" + +namespace OHOS { +namespace CryptoFramework { +NapiECCKeyUtil::NapiECCKeyUtil() {} + +NapiECCKeyUtil::~NapiECCKeyUtil() {} + +napi_value NapiECCKeyUtil::JsGenECCCommonParamsSpec(napi_env env, napi_callback_info info) +{ + size_t expectedArgc = ARGS_SIZE_ONE; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr); + + 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; + } + + std::string algName; + if (!GetStringFromJSParams(env, argv[0], algName)) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to get algoName.")); + LOGE("failed to get algoName."); + return NapiGetNull(env); + } + + HcfEccCommParamsSpec *eccCommParamsSpec = nullptr; + if (HcfEccKeyUtilCreate(algName.c_str(), &eccCommParamsSpec) != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "create c generator fail.")); + LOGE("create c generator fail."); + return NapiGetNull(env); + } + napi_value instance = ConvertEccCommParamsSpecToNapiValue(env, eccCommParamsSpec); + FreeEccCommParamsSpec(eccCommParamsSpec); + return instance; +} + +napi_value NapiECCKeyUtil::ECCKeyUtilConstructor(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = ARGS_SIZE_ONE; + napi_value argv[ARGS_SIZE_ONE] = { nullptr }; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); + return thisVar; +} + +napi_value NapiECCKeyUtil::GenECCCommonParamSpec(napi_env env) +{ + napi_value cons = nullptr; + napi_property_descriptor clzDes[] = { + DECLARE_NAPI_STATIC_FUNCTION("genECCCommonParamsSpec", NapiECCKeyUtil::JsGenECCCommonParamsSpec), + }; + NAPI_CALL(env, napi_define_class(env, "ECCKeyUtil", NAPI_AUTO_LENGTH, NapiECCKeyUtil::ECCKeyUtilConstructor, + nullptr, sizeof(clzDes) / sizeof(clzDes[0]), clzDes, &cons)); + return cons; +} + +void NapiECCKeyUtil::DefineNapiECCKeyUtilJSClass(napi_env env, napi_value exports) +{ + napi_set_named_property(env, exports, "ECCKeyUtil", NapiECCKeyUtil::GenECCCommonParamSpec(env)); +} +} // CryptoFramework +} // OHOS diff --git a/frameworks/js/napi/crypto/src/napi_init.cpp b/frameworks/js/napi/crypto/src/napi_init.cpp index f4ca245..e61f4c1 100644 --- a/frameworks/js/napi/crypto/src/napi_init.cpp +++ b/frameworks/js/napi/crypto/src/napi_init.cpp @@ -20,6 +20,7 @@ #include "napi_asy_key_spec_generator.h" #include "napi_sym_key_generator.h" #include "napi_cipher.h" +#include "napi_ecc_key_util.h" #include "napi_key_pair.h" #include "napi_pri_key.h" #include "napi_pub_key.h" @@ -150,6 +151,7 @@ static napi_value CreateCipherSpecItemCode(napi_env env) AddUint32Property(env, code, "OAEP_MD_NAME_STR", OAEP_MD_NAME_STR); AddUint32Property(env, code, "OAEP_MGF_NAME_STR", OAEP_MGF_NAME_STR); AddUint32Property(env, code, "OAEP_MGF1_MD_STR", OAEP_MGF1_MD_STR); + AddUint32Property(env, code, "SM2_MD_NAME_STR", SM2_MD_NAME_STR); AddUint32Property(env, code, "OAEP_MGF1_PSRC_UINT8ARR", OAEP_MGF1_PSRC_UINT8ARR); return code; } @@ -173,6 +175,7 @@ static napi_value CreateSignSpecItemCode(napi_env env) AddUint32Property(env, code, "PSS_MGF1_MD_STR", PSS_MGF1_MD_STR); AddUint32Property(env, code, "PSS_SALT_LEN_NUM", PSS_SALT_LEN_INT); AddUint32Property(env, code, "PSS_TRAILER_FIELD_NUM", PSS_TRAILER_FIELD_INT); + AddUint32Property(env, code, "SM2_USER_ID_UINT8ARR", SM2_USER_ID_UINT8ARR); return code; } @@ -216,6 +219,7 @@ static napi_value ModuleExport(napi_env env, napi_value exports) NapiRand::DefineRandJSClass(env, exports); NapiCipher::DefineCipherJSClass(env, exports); NapiKdf::DefineKdfJSClass(env, exports); + NapiECCKeyUtil::DefineNapiECCKeyUtilJSClass(env, exports); LOGI("module init end."); return exports; } diff --git a/frameworks/js/napi/crypto/src/napi_sign.cpp b/frameworks/js/napi/crypto/src/napi_sign.cpp index ac1c11b..67a28fd 100644 --- a/frameworks/js/napi/crypto/src/napi_sign.cpp +++ b/frameworks/js/napi/crypto/src/napi_sign.cpp @@ -618,8 +618,8 @@ napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) } HcfSign *sign = nullptr; - HcfResult res = HcfSignCreate(algName.c_str(), &sign); - if (res != HCF_SUCCESS) { + HcfResult ret = HcfSignCreate(algName.c_str(), &sign); + if (ret != HCF_SUCCESS) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "create c sign fail.")); LOGE("create c sign fail."); return nullptr; @@ -640,7 +640,60 @@ napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) return NapiWrapSign(env, instance, napiSign); } -// sign setSignSpec(itemType :signSpecItem, itemValue : number) +static HcfResult SetSignUserIdUintArray(napi_env env, napi_value *argv, HcfSign *sign) +{ + HcfBlob *blob = nullptr; + blob = GetBlobFromNapiUint8Arr(env, argv[1]); + HcfResult ret = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, *blob); + if (ret != HCF_SUCCESS) { + HcfBlobDataFree(blob); + HcfFree(blob); + napi_throw(env, GenerateBusinessError(env, ret, "c setSignSpecUint8Array failed.")); + LOGE("c setSignSpecUint8Array failed."); + return HCF_INVALID_PARAMS; + } + HcfBlobDataFree(blob); + HcfFree(blob); + return ret; +} + +static HcfResult SetSignSaltLenInt(napi_env env, napi_value *argv, HcfSign *sign) +{ + int32_t saltLen = 0; + if (napi_get_value_int32(env, argv[1], &saltLen) != napi_ok) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get signSpec saltLen failed!")); + LOGE("get signSpec saltLen failed!"); + return HCF_INVALID_PARAMS; + } + HcfResult ret = HCF_SUCCESS; + ret = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, saltLen); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "c setSignSpecNumber fail.")); + LOGE("c setSignSpecNumber fail."); + return HCF_INVALID_PARAMS; + } + return ret; +} + +static HcfResult SetDetailSignSpec(napi_env env, napi_value *argv, SignSpecItem item, HcfSign *sign) +{ + HcfResult result = HCF_INVALID_PARAMS; + + switch (item) { + case SM2_USER_ID_UINT8ARR: + result = SetSignUserIdUintArray(env, argv, sign); + break; + case PSS_SALT_LEN_INT: + result = SetSignSaltLenInt(env, argv, sign); + break; + default: + LOGE("specItem not support."); + break; + } + return result; +} + +// sign setSignSpec(itemType :signSpecItem, itemValue : number|string) napi_value NapiSign::JsSetSignSpec(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; @@ -661,12 +714,6 @@ napi_value NapiSign::JsSetSignSpec(napi_env env, napi_callback_info info) LOGE("get signspecitem failed!"); return nullptr; } - int32_t saltLen; - if (napi_get_value_int32(env, argv[1], &saltLen) != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get signSpec saltLen failed!")); - LOGE("get signSpec saltLen failed!"); - return nullptr; - } napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); if (status != napi_ok || napiSign == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap napiSign obj!")); @@ -674,10 +721,9 @@ napi_value NapiSign::JsSetSignSpec(napi_env env, napi_callback_info info) return nullptr; } HcfSign *sign = napiSign->GetSign(); - HcfResult res = sign->setSignSpecInt(sign, item, saltLen); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "c setSignSpecNumber fail.")); - LOGE("c setSignSpecNumber fail."); + if (SetDetailSignSpec(env, argv, item, sign) != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to set sign spec!")); + LOGE("failed to set sign spec!"); return nullptr; } return thisVar; @@ -686,9 +732,9 @@ napi_value NapiSign::JsSetSignSpec(napi_env env, napi_callback_info info) static napi_value GetSignSpecString(napi_env env, SignSpecItem item, HcfSign *sign) { char *returnString = nullptr; - HcfResult res = sign->getSignSpecString(sign, item, &returnString); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "C getSignSpecString failed.")); + HcfResult ret = sign->getSignSpecString(sign, item, &returnString); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "C getSignSpecString failed.")); LOGE("c getSignSpecString fail."); return nullptr; } @@ -702,9 +748,9 @@ static napi_value GetSignSpecString(napi_env env, SignSpecItem item, HcfSign *si static napi_value GetSignSpecNumber(napi_env env, SignSpecItem item, HcfSign *sign) { int returnInt; - HcfResult res = sign->getSignSpecInt(sign, item, &returnInt); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "C getSignSpecInt failed.")); + HcfResult ret = sign->getSignSpecInt(sign, item, &returnInt); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "C getSignSpecInt failed.")); LOGE("c getSignSpecInt fail."); return nullptr; } @@ -729,8 +775,8 @@ napi_value NapiSign::JsGetSignSpec(napi_env env, napi_callback_info info) } SignSpecItem item; if (napi_get_value_uint32(env, argv[0], reinterpret_cast(&item)) != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get getSignSpecString failed!")); - LOGE("get getSignSpecString failed!"); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get signSpecItem failed!")); + LOGE("get signSpecItem failed!"); return nullptr; } @@ -753,7 +799,7 @@ napi_value NapiSign::JsGetSignSpec(napi_env env, napi_callback_info info) } else if (type == SPEC_ITEM_TYPE_NUM) { return GetSignSpecNumber(env, item, sign); } else { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "SignSpecItem not support!")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "signSpecItem not support!")); return nullptr; } } diff --git a/frameworks/js/napi/crypto/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp index 7227ae8..ab540cc 100644 --- a/frameworks/js/napi/crypto/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -14,7 +14,7 @@ */ #include "napi_utils.h" - +#include "params_parser.h" #include "log.h" #include "memory.h" #include "securec.h" @@ -25,6 +25,7 @@ #include "detailed_dsa_key_params.h" #include "detailed_ecc_key_params.h" #include "detailed_rsa_key_params.h" +#include "utils.h" namespace OHOS { namespace CryptoFramework { @@ -79,6 +80,9 @@ int32_t GetSignSpecType(SignSpecItem targetItemType) targetItemType == PSS_MGF1_MD_STR) { return SPEC_ITEM_TYPE_STR; } + if (targetItemType == SM2_USER_ID_UINT8ARR) { + return SPEC_ITEM_TYPE_UINT8ARR; + } if (targetItemType == PSS_SALT_LEN_INT || targetItemType == PSS_TRAILER_FIELD_INT) { return SPEC_ITEM_TYPE_NUM; } @@ -89,7 +93,7 @@ int32_t GetSignSpecType(SignSpecItem targetItemType) int32_t GetCipherSpecType(CipherSpecItem targetItemType) { if (targetItemType == OAEP_MD_NAME_STR || targetItemType == OAEP_MGF_NAME_STR || - targetItemType == OAEP_MGF1_MD_STR) { + targetItemType == OAEP_MGF1_MD_STR || targetItemType == SM2_MD_NAME_STR) { return SPEC_ITEM_TYPE_STR; } if (targetItemType == OAEP_MGF1_PSRC_UINT8ARR) { @@ -766,7 +770,7 @@ static bool InitEccDetailAsyKeySpec(napi_env env, napi_value arg, HcfEccCommPara return true; } -static bool InitEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfEccCommParamsSpec *spec) +static bool InitEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfEccCommParamsSpec *spec, string algName) { size_t algNameLen = ECC_ASY_KEY_SPEC.length(); spec->base.algName = static_cast(HcfMalloc(algNameLen + 1, 0)); @@ -774,7 +778,7 @@ static bool InitEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfEccCommPara LOGE("malloc ECC algName failed!"); return false; } - (void)memcpy_s(spec->base.algName, algNameLen+ 1, ECC_ASY_KEY_SPEC.c_str(), algNameLen); + (void)memcpy_s(spec->base.algName, algNameLen+ 1, algName.c_str(), algNameLen); spec->base.specType = HCF_COMMON_PARAMS_SPEC; // get h @@ -810,14 +814,14 @@ static bool InitEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfEccCommPara return true; } -static bool GetEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec) +static bool GetEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec, string algName) { HcfEccCommParamsSpec *spec = reinterpret_cast(HcfMalloc(sizeof(HcfEccCommParamsSpec), 0)); if (spec == nullptr) { LOGE("malloc falied!"); return false; } - if (!InitEccCommonAsyKeySpec(env, arg, spec)) { + if (!InitEccCommonAsyKeySpec(env, arg, spec, algName)) { LOGE("InitEccCommonAsyKeySpec failed!"); HcfFree(spec); return false; @@ -826,7 +830,7 @@ static bool GetEccCommonAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParams return true; } -static bool GetEccPriKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec) +static bool GetEccPriKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec, string algName) { HcfEccPriKeyParamsSpec *spec = reinterpret_cast(HcfMalloc(sizeof(HcfEccPriKeyParamsSpec), 0)); @@ -841,7 +845,7 @@ static bool GetEccPriKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec * HcfFree(spec); return false; } - if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec))) { + if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec), algName)) { LOGE("InitEccCommonAsyKeySpec failed!"); HcfFree(spec); return false; @@ -860,7 +864,7 @@ static bool GetEccPriKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec * return true; } -static bool GetEccPubKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec) +static bool GetEccPubKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec, string algName) { HcfEccPubKeyParamsSpec *spec = reinterpret_cast(HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0)); @@ -875,7 +879,7 @@ static bool GetEccPubKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec * HcfFree(spec); return false; } - if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec))) { + if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec), algName)) { LOGE("InitEccCommonAsyKeySpec failed!"); HcfFree(spec); return false; @@ -892,7 +896,7 @@ static bool GetEccPubKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec * return true; } -static bool GetEccKeyPairAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec) +static bool GetEccKeyPairAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec, string algName) { HcfEccKeyPairParamsSpec *spec = reinterpret_cast(HcfMalloc(sizeof(HcfEccKeyPairParamsSpec), 0)); @@ -907,7 +911,7 @@ static bool GetEccKeyPairAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParam HcfFree(spec); return false; } - if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec))) { + if (!InitEccCommonAsyKeySpec(env, commSpecValue, reinterpret_cast(spec), algName)) { LOGE("InitEccCommonAsyKeySpec failed!"); HcfFree(spec); return false; @@ -935,7 +939,7 @@ static bool GetEccKeyPairAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParam return true; } -static bool GetEccAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec) +static bool GetEccAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec **asyKeySpec, string algName) { napi_value data = nullptr; napi_valuetype valueType = napi_undefined; @@ -953,14 +957,15 @@ static bool GetEccAsyKeySpec(napi_env env, napi_value arg, HcfAsyKeyParamsSpec * return false; } if (asyKeySpecType == HCF_COMMON_PARAMS_SPEC) { - return GetEccCommonAsyKeySpec(env, arg, asyKeySpec); + return GetEccCommonAsyKeySpec(env, arg, asyKeySpec, algName); } else if (asyKeySpecType == HCF_PRIVATE_KEY_SPEC) { - return GetEccPriKeySpec(env, arg, asyKeySpec); + return GetEccPriKeySpec(env, arg, asyKeySpec, algName); } else if (asyKeySpecType == HCF_PUBLIC_KEY_SPEC) { - return GetEccPubKeySpec(env, arg, asyKeySpec); + return GetEccPubKeySpec(env, arg, asyKeySpec, algName); } else if (asyKeySpecType == HCF_KEY_PAIR_SPEC) { - return GetEccKeyPairAsyKeySpec(env, arg, asyKeySpec); + return GetEccKeyPairAsyKeySpec(env, arg, asyKeySpec, algName); } else { + LOGE("keySpec not support!"); return false; } } @@ -1114,12 +1119,12 @@ bool GetAsyKeySpecFromNapiValue(napi_env env, napi_value arg, HcfAsyKeyParamsSpe } if (algName.compare(DSA_ASY_KEY_SPEC) == 0) { return GetDsaAsyKeySpec(env, arg, asyKeySpec); - } else if (algName.compare(ECC_ASY_KEY_SPEC) == 0) { - return GetEccAsyKeySpec(env, arg, asyKeySpec); + } else if (algName.compare(ECC_ASY_KEY_SPEC) == 0 || algName.compare(SM2_ASY_KEY_SPEC) == 0) { + return GetEccAsyKeySpec(env, arg, asyKeySpec, algName); } else if (algName.compare(RSA_ASY_KEY_SPEC) == 0) { return GetRsaAsyKeySpec(env, arg, asyKeySpec); } else { - LOGE("GetAsyKeySpecFromNapiValue fialed, algName not support."); + LOGE("AlgName not support! [AlgName]: %s", algName.c_str()); return false; } } @@ -1377,5 +1382,250 @@ napi_value GetResourceName(napi_env env, const char *name) napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &resourceName); return resourceName; } + +static bool CheckEccCommonParamSpecBase(napi_env env, HcfEccCommParamsSpec *blob) +{ + if (blob->a.data == nullptr || blob->a.len == 0) { + LOGE("Invalid blob a!"); + return false; + } + if (blob->b.data == nullptr || blob->b.len == 0) { + LOGE("Invalid blob b!"); + return false; + } + if (blob->n.data == nullptr || blob->n.len == 0) { + LOGE("Invalid blob n!"); + return false; + } + return true; +} + +bool CheckEccCommonParamSpec(napi_env env, HcfEccCommParamsSpec *blob) +{ + if (blob == nullptr) { + LOGE("Invalid blob!"); + return false; + } + if (!CheckEccCommonParamSpecBase(env, blob)) { + LOGE("Invalid blob ecc commonParamSpec base!"); + return false; + } + if (blob->base.algName == nullptr) { + LOGE("Invalid blob algName!"); + return false; + } + if (blob->field == nullptr) { + LOGE("Invalid blob field!"); + return false; + } + if (blob->field->fieldType == nullptr) { + LOGE("Invalid blob fieldType!"); + return false; + } + if (blob->g.x.data == nullptr || blob->g.x.len == 0) { + LOGE("Invalid blob point x!"); + return false; + } + if (blob->g.y.data == nullptr || blob->g.y.len == 0) { + LOGE("Invalid blob point y!"); + return false; + } + HcfECFieldFp *tmpField = reinterpret_cast(blob->field); + if (tmpField->p.data == nullptr || tmpField->p.len == 0) { + LOGE("Invalid blob p!"); + return false; + } + return true; +} + +napi_value ConvertEccCommonParamFieldFpToNapiValue(napi_env env, HcfEccCommParamsSpec *blob) +{ + napi_value fieldFp; + napi_value fieldType; + napi_status status = napi_create_object(env, &fieldFp); + if (status != napi_ok) { + LOGE("create fieldFp failed!"); + return NapiGetNull(env); + } + size_t fieldTypeLength = HcfStrlen(blob->field->fieldType); + if (!fieldTypeLength) { + LOGE("fieldType is empty!"); + return NapiGetNull(env); + } + status = napi_create_string_utf8(env, blob->field->fieldType, fieldTypeLength, &fieldType); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, fieldFp, "fieldType", fieldType); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + HcfECFieldFp *tmpField = reinterpret_cast(blob->field); + napi_value p = ConvertBigIntToNapiValue(env, &(tmpField->p)); + if (p == nullptr) { + LOGE("p is null!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, fieldFp, "p", p); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + return fieldFp; +} + +napi_value ConvertEccCommonParamPointToNapiValue(napi_env env, HcfEccCommParamsSpec *blob) +{ + napi_value point; + napi_status status = napi_create_object(env, &point); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + napi_value x = ConvertBigIntToNapiValue(env, &(blob->g.x)); + napi_value y = ConvertBigIntToNapiValue(env, &(blob->g.y)); + if (x == nullptr) { + LOGE("x is null!"); + return NapiGetNull(env); + } + if (y == nullptr) { + LOGE("y is null!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, point, "x", x); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, point, "y", y); + if (status != napi_ok) { + LOGE("create object failed!"); + return NapiGetNull(env); + } + return point; +} + +bool BuildSetNamedProperty(napi_env env, HcfBigInteger *number, const char *name, napi_value *intence) +{ + napi_value value = ConvertBigIntToNapiValue(env, number); + napi_status status = napi_set_named_property(env, *intence, name, value); + if (status != napi_ok) { + LOGE("create value failed!"); + return false; + } + return true; +} + +bool BuildIntancePartertoNapiValueSon(napi_env env, napi_status status, HcfEccCommParamsSpec *blob, napi_value *intence) +{ + if (!BuildSetNamedProperty(env, &(blob->a), "a", intence)) { + LOGE("build setNamedProperty a failed!"); + return false; + } + if (!BuildSetNamedProperty(env, &(blob->b), "b", intence)) { + LOGE("build setNamedProperty b failed!"); + return false; + } + if (!BuildSetNamedProperty(env, &(blob->n), "n", intence)) { + LOGE("build setNamedProperty n failed!"); + return false; + } + napi_value h; + status = napi_create_int32(env, blob->h, &h); + if (status != napi_ok) { + LOGE("create h uint32 failed!"); + return false; + } + status = napi_set_named_property(env, *intence, "h", h); + if (status != napi_ok) { + LOGE("create h uint32 failed!"); + return false; + } + return true; +} + +bool BuildIntenceParterToNapiValue(napi_env env, HcfEccCommParamsSpec *blob, napi_value *intence) +{ + napi_value algName; + size_t algNameLength = HcfStrlen(blob->base.algName); + if (!algNameLength) { + LOGE("algName is enpty!"); + return false; + } + napi_status status = napi_create_string_utf8(env, blob->base.algName, algNameLength, &algName); + if (status != napi_ok) { + LOGE("create algName failed!"); + return false; + } + napi_value specType; + status = napi_create_uint32(env, blob->base.specType, &specType); + if (status != napi_ok) { + LOGE("create uint32 failed!"); + return false; + } + status = napi_set_named_property(env, *intence, "algName", algName); + if (status != napi_ok) { + LOGE("create set algName failed!"); + return false; + } + status = napi_set_named_property(env, *intence, "specType", specType); + if (status != napi_ok) { + LOGE("create set specType failed!"); + return false; + } + if (!BuildIntancePartertoNapiValueSon(env, status, blob, intence)) { + LOGE("create intance parter napi value failed!"); + return false; + } + return true; +} + +napi_value ConvertEccCommParamsSpecToNapiValue(napi_env env, HcfEccCommParamsSpec *blob) +{ + if (!CheckEccCommonParamSpec(env, blob)) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "Invalid blob!")); + LOGE("Invalid blob!"); + return NapiGetNull(env); + } + napi_value intence; + napi_status status = napi_create_object(env, &intence); + if (status != napi_ok) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "create object failed!")); + LOGE("create object failed!"); + return NapiGetNull(env); + } + napi_value point = ConvertEccCommonParamPointToNapiValue(env, blob); + if (point == NapiGetNull(env)) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "covert commonParam failed!")); + LOGE("Covert commonParam failed!"); + return NapiGetNull(env); + } + napi_value field = ConvertEccCommonParamFieldFpToNapiValue(env, blob); + if (field == NapiGetNull(env)) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "covert commonParam fieldFp failed!")); + LOGE("Covert commonParam fieldFp failed!"); + return NapiGetNull(env); + } + if (!BuildIntenceParterToNapiValue(env, blob, &intence)) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "build object failed!")); + LOGE("Build object failed!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, intence, "field", field); + if (status != napi_ok) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "set fieldFp failed!")); + LOGE("set fieldFp failed!"); + return NapiGetNull(env); + } + status = napi_set_named_property(env, intence, "g", point); + if (status != napi_ok) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "set g failed!")); + LOGE("set g failed!"); + return NapiGetNull(env); + } + return intence; +} } // namespace CryptoFramework } // namespace OHOS diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index 6d4c736..56dd954 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -646,9 +646,9 @@ napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) } HcfVerify *verify = nullptr; - HcfResult res = HcfVerifyCreate(algName.c_str(), &verify); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "create c verify fail.")); + HcfResult ret = HcfVerifyCreate(algName.c_str(), &verify); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "create c verify fail.")); LOGE("create c verify fail."); return nullptr; } @@ -668,7 +668,59 @@ napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) return NapiWrapVerify(env, instance, napiVerify); } -// verify setVerifySpec(itemType :VerifySpecItem, itemValue : number) +static HcfResult SetVerifyUserIdUintArray(napi_env env, napi_value *argv, HcfVerify *verify) +{ + HcfBlob *blob = nullptr; + blob = GetBlobFromNapiUint8Arr(env, argv[1]); + HcfResult ret = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, *blob); + if (ret != HCF_SUCCESS) { + HcfBlobDataFree(blob); + HcfFree(blob); + napi_throw(env, GenerateBusinessError(env, ret, "c SetVerifyUserIdUintArray failed.")); + LOGE("c SetVerifyUserIdUintArray failed."); + return HCF_INVALID_PARAMS; + } + HcfBlobDataFree(blob); + HcfFree(blob); + return ret; +} + +static HcfResult SetVerifySaltLenInt(napi_env env, napi_value *argv, HcfVerify *verify) +{ + int32_t saltLen = 0; + if (napi_get_value_int32(env, argv[1], &saltLen) != napi_ok) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get signSpec saltLen failed!")); + LOGE("get signSpec saltLen failed!"); + return HCF_INVALID_PARAMS; + } + HcfResult ret = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, saltLen); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "c setSignSpecNumber fail.")); + LOGE("c setSignSpecNumber fail."); + return HCF_INVALID_PARAMS; + } + return ret; +} + +static HcfResult SetDetailVerifySpec(napi_env env, napi_value *argv, SignSpecItem item, HcfVerify *verify) +{ + HcfResult result = HCF_INVALID_PARAMS; + + switch (item) { + case SM2_USER_ID_UINT8ARR: + result = SetVerifyUserIdUintArray(env, argv, verify); + break; + case PSS_SALT_LEN_INT: + result = SetVerifySaltLenInt(env, argv, verify); + break; + default: + LOGE("specItem not support."); + break; + } + return result; +} + +// verify setVerifySpec(itemType :VerifySpecItem, itemValue : number|string) napi_value NapiVerify::JsSetVerifySpec(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; @@ -688,12 +740,6 @@ napi_value NapiVerify::JsSetVerifySpec(napi_env env, napi_callback_info info) LOGE("get signspecitem failed!"); return nullptr; } - int32_t saltLen; - if (napi_get_value_int32(env, argv[1], &saltLen) != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get VerifySpec saltLen failed!")); - LOGE("get VerifySpec saltLen failed!"); - return nullptr; - } napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); if (status != napi_ok || napiVerify == nullptr) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap napiVerify obj!")); @@ -701,10 +747,9 @@ napi_value NapiVerify::JsSetVerifySpec(napi_env env, napi_callback_info info) return nullptr; } HcfVerify *verify = napiVerify->GetVerify(); - HcfResult res = verify->setVerifySpecInt(verify, item, saltLen); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "c setVerifySpecNumber fail.")); - LOGE("c setVerifySpecNumber fail."); + if (SetDetailVerifySpec(env, argv, item, verify) != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to set verify spec!")); + LOGE("failed to set verify spec!"); return nullptr; } return thisVar; @@ -713,9 +758,9 @@ napi_value NapiVerify::JsSetVerifySpec(napi_env env, napi_callback_info info) static napi_value GetVerifySpecString(napi_env env, SignSpecItem item, HcfVerify *verify) { char *returnString = nullptr; - HcfResult res = verify->getVerifySpecString(verify, item, &returnString); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "C getVerifySpecString failed.")); + HcfResult ret = verify->getVerifySpecString(verify, item, &returnString); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "C getVerifySpecString failed.")); LOGE("c getVerifySpecString fail."); return nullptr; } @@ -729,9 +774,9 @@ static napi_value GetVerifySpecString(napi_env env, SignSpecItem item, HcfVerify static napi_value GetVerifySpecNumber(napi_env env, SignSpecItem item, HcfVerify *verify) { int returnInt; - HcfResult res = verify->getVerifySpecInt(verify, item, &returnInt); - if (res != HCF_SUCCESS) { - napi_throw(env, GenerateBusinessError(env, res, "C getVerifySpecInt failed.")); + HcfResult ret = verify->getVerifySpecInt(verify, item, &returnInt); + if (ret != HCF_SUCCESS) { + napi_throw(env, GenerateBusinessError(env, ret, "C getVerifySpecInt failed.")); LOGE("c getVerifySpecInt fail."); return nullptr; } @@ -756,8 +801,8 @@ napi_value NapiVerify::JsGetVerifySpec(napi_env env, napi_callback_info info) } SignSpecItem item; if (napi_get_value_uint32(env, argv[0], reinterpret_cast(&item)) != napi_ok) { - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get getVerifySpecString failed!")); - LOGE("get getVerifySpecString failed!"); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get signSpecItem failed!")); + LOGE("get signSpecItem failed!"); return nullptr; } diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index b034204..4fe71c5 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -24,6 +24,7 @@ #include "detailed_ecc_key_params.h" #include "dsa_asy_key_generator_openssl.h" #include "ecc_asy_key_generator_openssl.h" +#include "key_utils.h" #include "params_parser.h" #include "rsa_asy_key_generator_openssl.h" #include "sm2_asy_key_generator_openssl.h" @@ -33,6 +34,7 @@ #define ALG_NAME_DSA "DSA" #define ALG_NAME_ECC "ECC" +#define ALG_NAME_SM2 "SM2" #define ALG_NAME_RSA "RSA" #define ASY_KEY_GENERATOR_CLASS "HcfAsyKeyGenerator" #define ASY_KEY_GENERATOR_BY_SPEC_CLASS "HcfAsyKeyGeneratorBySpec" @@ -90,7 +92,21 @@ static const KeyTypeAlg KEY_TYPE_MAP[] = { { HCF_ALG_DSA_1024, HCF_DSA_KEY_SIZE_1024, HCF_ALG_DSA }, { HCF_ALG_DSA_2048, HCF_DSA_KEY_SIZE_2048, HCF_ALG_DSA }, { HCF_ALG_DSA_3072, HCF_DSA_KEY_SIZE_3072, HCF_ALG_DSA }, - { HCF_ALG_SM2_256, HCF_ALG_SM2_256, HCF_ALG_SM2 } + { HCF_ALG_SM2_256, HCF_ALG_SM2_256, HCF_ALG_SM2 }, + { HCF_ALG_ECC_BP160R1, HCF_ALG_ECC_BP160R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP160T1, HCF_ALG_ECC_BP160T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP192R1, HCF_ALG_ECC_BP192R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP192T1, HCF_ALG_ECC_BP192T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP224R1, HCF_ALG_ECC_BP224R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP224T1, HCF_ALG_ECC_BP224T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP256R1, HCF_ALG_ECC_BP256R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP256T1, HCF_ALG_ECC_BP256T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP320R1, HCF_ALG_ECC_BP320R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP320T1, HCF_ALG_ECC_BP320T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP384R1, HCF_ALG_ECC_BP384R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP384T1, HCF_ALG_ECC_BP384T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP512R1, HCF_ALG_ECC_BP512R1, HCF_ALG_ECC }, + { HCF_ALG_ECC_BP512T1, HCF_ALG_ECC_BP512T1, HCF_ALG_ECC } }; static bool IsDsaCommParamsSpecValid(HcfDsaCommParamsSpec *paramsSpec) { @@ -322,7 +338,7 @@ static bool IsParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec) } if (strcmp(paramsSpec->algName, ALG_NAME_DSA) == 0) { return IsDsaParamsSpecValid(paramsSpec); - } else if (strcmp(paramsSpec->algName, ALG_NAME_ECC) == 0) { + } else if (strcmp(paramsSpec->algName, ALG_NAME_ECC) == 0 || strcmp(paramsSpec->algName, ALG_NAME_SM2) == 0) { return IsEccParamsSpecValid(paramsSpec); } else if (strcmp(paramsSpec->algName, ALG_NAME_RSA) == 0) { return IsRsaParamsSpecValid(paramsSpec); @@ -404,19 +420,6 @@ static HcfResult ParseAsyKeyGenParams(const HcfParaConfig* config, void *params) return ret; } -static HcfResult CopyAsyKeyParamsSpec(const HcfAsyKeyParamsSpec *srcSpec, HcfAsyKeyParamsSpec *destSpec) -{ - int srcAlgNameLen = strlen(srcSpec->algName); - destSpec->algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0); - if (destSpec->algName == NULL) { - LOGE("Failed to allocate alg name memory"); - return HCF_ERR_MALLOC; - } - (void)memcpy_s(destSpec->algName, srcAlgNameLen, srcSpec->algName, srcAlgNameLen); - destSpec->specType = srcSpec->specType; - return HCF_SUCCESS; -} - static HcfResult CopyDsaCommonSpec(const HcfDsaCommParamsSpec *srcSpec, HcfDsaCommParamsSpec *destSpec) { if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) { @@ -550,121 +553,6 @@ static HcfResult CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, return ret; } -static HcfResult CopyEcField(const HcfECField *src, HcfECField **dest) -{ - HcfECField *tmpField = (HcfECField *)HcfMalloc(sizeof(HcfECFieldFp), 0); - if (tmpField == NULL) { - LOGE("Alloc memory failed."); - return HCF_ERR_MALLOC; - } - - int32_t srcFieldTypeLen = strlen(src->fieldType); - tmpField->fieldType = (char *)HcfMalloc(srcFieldTypeLen + 1, 0); - if (tmpField->fieldType == NULL) { - LOGE("Failed to allocate field memory."); - HcfFree(tmpField); - return HCF_ERR_MALLOC; - } - HcfECFieldFp *tmpDest = (HcfECFieldFp *)(tmpField); - HcfECFieldFp *tmpSrc = (HcfECFieldFp *)(src); - tmpDest->p.data = (unsigned char *)HcfMalloc(tmpSrc->p.len, 0); - if (tmpDest->p.data == NULL) { - LOGE("Failed to allocate b data memory"); - HcfFree(tmpField->fieldType); - HcfFree(tmpField); - return HCF_ERR_MALLOC; - } - (void)memcpy_s(tmpField->fieldType, srcFieldTypeLen, src->fieldType, srcFieldTypeLen); - (void)memcpy_s(tmpDest->p.data, tmpSrc->p.len, tmpSrc->p.data, tmpSrc->p.len); - tmpDest->p.len = tmpSrc->p.len; - - *dest = tmpField; - return HCF_SUCCESS; -} - -static HcfResult CopyPoint(const HcfPoint *src, HcfPoint *dest) -{ - dest->x.data = (unsigned char *)HcfMalloc(src->x.len, 0); - if (dest->x.data == NULL) { - LOGE("Failed to allocate x data memory"); - return HCF_ERR_MALLOC; - } - dest->y.data = (unsigned char *)HcfMalloc(src->y.len, 0); - if (dest->y.data == NULL) { - LOGE("Failed to allocate y data memory"); - HcfFree(dest->x.data); - dest->x.data = NULL; - return HCF_ERR_MALLOC; - } - (void)memcpy_s(dest->x.data, src->x.len, src->x.data, src->x.len); - (void)memcpy_s(dest->y.data, src->y.len, src->y.data, src->y.len); - dest->x.len = src->x.len; - dest->y.len = src->y.len; - return HCF_SUCCESS; -} - -static HcfResult CopyEccCommonSpec(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec *destSpec) -{ - if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) { - return HCF_INVALID_PARAMS; - } - destSpec->a.data = (unsigned char *)HcfMalloc(srcSpec->a.len, 0); - if (destSpec->a.data == NULL) { - LOGE("Failed to allocate a data memory"); - FreeEccCommParamsSpec(destSpec); - return HCF_ERR_MALLOC; - } - destSpec->b.data = (unsigned char *)HcfMalloc(srcSpec->b.len, 0); - if (destSpec->b.data == NULL) { - LOGE("Failed to allocate b data memory"); - FreeEccCommParamsSpec(destSpec); - return HCF_ERR_MALLOC; - } - destSpec->n.data = (unsigned char *)HcfMalloc(srcSpec->n.len, 0); - if (destSpec->n.data == NULL) { - LOGE("Failed to allocate n data memory"); - FreeEccCommParamsSpec(destSpec); - return HCF_ERR_MALLOC; - } - HcfResult res = CopyEcField(srcSpec->field, &(destSpec->field)); - if (res != HCF_SUCCESS) { - LOGE("Failed to allocate field data memory"); - FreeEccCommParamsSpec(destSpec); - return HCF_ERR_MALLOC; - } - res = CopyPoint(&(srcSpec->g), &(destSpec->g)); - if (res != HCF_SUCCESS) { - LOGE("Failed to allocate field data memory"); - FreeEccCommParamsSpec(destSpec); - return HCF_ERR_MALLOC; - } - destSpec->h = srcSpec->h; - (void)memcpy_s(destSpec->a.data, srcSpec->a.len, srcSpec->a.data, srcSpec->a.len); - (void)memcpy_s(destSpec->b.data, srcSpec->b.len, srcSpec->b.data, srcSpec->b.len); - (void)memcpy_s(destSpec->n.data, srcSpec->n.len, srcSpec->n.data, srcSpec->n.len); - destSpec->a.len = srcSpec->a.len; - destSpec->b.len = srcSpec->b.len; - destSpec->n.len = srcSpec->n.len; - return HCF_SUCCESS; -} - -static HcfResult CreateEccCommonSpecImpl(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec **destSpec) -{ - HcfEccCommParamsSpec *tmpSpec = (HcfEccCommParamsSpec *)HcfMalloc(sizeof(HcfEccCommParamsSpec), 0); - if (tmpSpec == NULL) { - LOGE("Failed to allocate dest spec memory"); - return HCF_ERR_MALLOC; - } - - if (CopyEccCommonSpec(srcSpec, tmpSpec) != HCF_SUCCESS) { - HcfFree(tmpSpec); - return HCF_INVALID_PARAMS; - } - - *destSpec = tmpSpec; - return HCF_SUCCESS; -} - static HcfResult CreateEccPubKeySpecImpl(const HcfEccPubKeyParamsSpec *srcSpec, HcfEccPubKeyParamsSpec **destSpec) { HcfEccPubKeyParamsSpec *tmpSpec = (HcfEccPubKeyParamsSpec *)HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0); @@ -883,6 +771,7 @@ static HcfResult CreateAsyKeyParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpe case HCF_ALG_DSA: ret = CreateDsaParamsSpecImpl(paramsSpec, impl); break; + case HCF_ALG_SM2: case HCF_ALG_ECC: ret = CreateEccParamsSpecImpl(paramsSpec, impl); break; diff --git a/frameworks/key/ecc_key_util.c b/frameworks/key/ecc_key_util.c new file mode 100644 index 0000000..ac571a7 --- /dev/null +++ b/frameworks/key/ecc_key_util.c @@ -0,0 +1,88 @@ +/* + * 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 "ecc_key_util.h" +#include +#include "ecc_key_util_spi.h" +#include "config.h" +#include "ecc_common_param_spec_generator_openssl.h" +#include "key_utils.h" +#include "params_parser.h" +#include "log.h" +#include "memory.h" +#include "utils.h" + +typedef HcfResult (*HcfEccCommParamsSpecCreateFunc)(HcfAsyKeyGenParams *, HcfEccCommParamsSpecSpi **); + +typedef struct { + HcfAlgValue algo; + + HcfEccCommParamsSpecCreateFunc createSpiFunc; +} HcfEccCommParamsSpecAbility; + +static const HcfEccCommParamsSpecAbility ASY_KEY_GEN_ABILITY_SET[] = { + { HCF_ALG_ECC, HcfECCCommonParamSpecCreate }, +}; + +static HcfEccCommParamsSpecCreateFunc FindAbility(HcfAsyKeyGenParams *params) +{ + if (params == NULL) { + LOGE("params is null"); + return NULL; + } + 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; + } + } + LOGE("Algo not support! [Algo]: %d", params->algo); + return NULL; +} + + +HcfResult HcfEccKeyUtilCreate(const char *algName, HcfEccCommParamsSpec **returnCommonParamSpec) +{ + if ((!IsStrValid(algName, HCF_MAX_ALGO_NAME_LEN)) || (returnCommonParamSpec == NULL)) { + LOGE("Failed to parser parmas!"); + return HCF_INVALID_PARAMS; + } + HcfAsyKeyGenParams params = { 0 }; + if (ParseCurveNameToParams(algName, ¶ms) != HCF_SUCCESS) { + LOGE("Failed to parser parmas!"); + return HCF_INVALID_PARAMS; + } + + HcfEccCommParamsSpecCreateFunc createSpiFunc = FindAbility(¶ms); + if (createSpiFunc == NULL) { + LOGE("Failed to find ability!"); + return HCF_NOT_SUPPORT; + } + + HcfEccCommParamsSpecSpi *spiInstance = NULL; + HcfResult ret = createSpiFunc(¶ms, &spiInstance); + if (ret != HCF_SUCCESS) { + LOGE("Failed to create spi object!"); + return ret; + } + if (CreateEccCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec) != HCF_SUCCESS) { + LOGE("Failed to create spi object!"); + FreeEccCommParamsSpec(&(spiInstance->paramsSpec)); + HcfFree(spiInstance); + return ret; + } + FreeEccCommParamsSpec(&(spiInstance->paramsSpec)); + HcfFree(spiInstance); + return HCF_SUCCESS; +} \ No newline at end of file diff --git a/frameworks/key/key_utils.c b/frameworks/key/key_utils.c new file mode 100644 index 0000000..677c3a8 --- /dev/null +++ b/frameworks/key/key_utils.c @@ -0,0 +1,160 @@ +/* + * 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 "key_utils.h" +#include +#include "config.h" +#include "params_parser.h" +#include "log.h" +#include "memory.h" +#include "utils.h" + +HcfResult CopyAsyKeyParamsSpec(const HcfAsyKeyParamsSpec *srcSpec, HcfAsyKeyParamsSpec *destSpec) +{ + size_t srcAlgNameLen = HcfStrlen(srcSpec->algName); + if (!srcAlgNameLen) { + LOGE("algName is enpty!"); + return HCF_INVALID_PARAMS; + } + destSpec->algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0); + if (destSpec->algName == NULL) { + LOGE("Failed to allocate alg name memory"); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(destSpec->algName, srcAlgNameLen, srcSpec->algName, srcAlgNameLen); + destSpec->specType = srcSpec->specType; + return HCF_SUCCESS; +} + +HcfResult CopyPoint(const HcfPoint *src, HcfPoint *dest) +{ + dest->x.data = (unsigned char *)HcfMalloc(src->x.len, 0); + if (dest->x.data == NULL) { + LOGE("Failed to allocate x data memory"); + return HCF_ERR_MALLOC; + } + dest->y.data = (unsigned char *)HcfMalloc(src->y.len, 0); + if (dest->y.data == NULL) { + LOGE("Failed to allocate y data memory"); + HcfFree(dest->x.data); + dest->x.data = NULL; + return HCF_ERR_MALLOC; + } + (void)memcpy_s(dest->x.data, src->x.len, src->x.data, src->x.len); + (void)memcpy_s(dest->y.data, src->y.len, src->y.data, src->y.len); + dest->x.len = src->x.len; + dest->y.len = src->y.len; + return HCF_SUCCESS; +} + +HcfResult CopyEcField(const HcfECField *src, HcfECField **dest) +{ + HcfECField *tmpField = (HcfECField *)HcfMalloc(sizeof(HcfECFieldFp), 0); + if (tmpField == NULL) { + LOGE("Alloc memory failed."); + return HCF_ERR_MALLOC; + } + size_t srcFieldTypeLen = HcfStrlen(src->fieldType); + if (!srcFieldTypeLen) { + LOGE("fieldType is empty!"); + HcfFree(tmpField); + return HCF_INVALID_PARAMS; + } + tmpField->fieldType = (char *)HcfMalloc(srcFieldTypeLen + 1, 0); + if (tmpField->fieldType == NULL) { + LOGE("Failed to allocate field memory."); + HcfFree(tmpField); + return HCF_ERR_MALLOC; + } + HcfECFieldFp *tmpDest = (HcfECFieldFp *)(tmpField); + HcfECFieldFp *tmpSrc = (HcfECFieldFp *)(src); + tmpDest->p.data = (unsigned char *)HcfMalloc(tmpSrc->p.len, 0); + if (tmpDest->p.data == NULL) { + LOGE("Failed to allocate b data memory"); + HcfFree(tmpField->fieldType); + HcfFree(tmpField); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(tmpField->fieldType, srcFieldTypeLen, src->fieldType, srcFieldTypeLen); + (void)memcpy_s(tmpDest->p.data, tmpSrc->p.len, tmpSrc->p.data, tmpSrc->p.len); + tmpDest->p.len = tmpSrc->p.len; + *dest = tmpField; + return HCF_SUCCESS; +} + +HcfResult CopyEccCommonSpec(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec *destSpec) +{ + if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) { + return HCF_INVALID_PARAMS; + } + destSpec->a.data = (unsigned char *)HcfMalloc(srcSpec->a.len, 0); + if (destSpec->a.data == NULL) { + LOGE("Failed to allocate a data memory"); + FreeEccCommParamsSpec(destSpec); + return HCF_ERR_MALLOC; + } + destSpec->b.data = (unsigned char *)HcfMalloc(srcSpec->b.len, 0); + if (destSpec->b.data == NULL) { + LOGE("Failed to allocate b data memory"); + FreeEccCommParamsSpec(destSpec); + return HCF_ERR_MALLOC; + } + destSpec->n.data = (unsigned char *)HcfMalloc(srcSpec->n.len, 0); + if (destSpec->n.data == NULL) { + LOGE("Failed to allocate n data memory"); + FreeEccCommParamsSpec(destSpec); + return HCF_ERR_MALLOC; + } + HcfResult res = CopyEcField(srcSpec->field, &(destSpec->field)); + if (res != HCF_SUCCESS) { + LOGE("Failed to allocate field data memory"); + FreeEccCommParamsSpec(destSpec); + return HCF_ERR_MALLOC; + } + res = CopyPoint(&(srcSpec->g), &(destSpec->g)); + if (res != HCF_SUCCESS) { + LOGE("Failed to allocate field data memory"); + FreeEccCommParamsSpec(destSpec); + return HCF_ERR_MALLOC; + } + destSpec->h = srcSpec->h; + (void)memcpy_s(destSpec->a.data, srcSpec->a.len, srcSpec->a.data, srcSpec->a.len); + (void)memcpy_s(destSpec->b.data, srcSpec->b.len, srcSpec->b.data, srcSpec->b.len); + (void)memcpy_s(destSpec->n.data, srcSpec->n.len, srcSpec->n.data, srcSpec->n.len); + destSpec->a.len = srcSpec->a.len; + destSpec->b.len = srcSpec->b.len; + destSpec->n.len = srcSpec->n.len; + return HCF_SUCCESS; +} + +HcfResult CreateEccCommonSpecImpl(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec **destSpec) +{ + if (srcSpec == NULL || destSpec == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + HcfEccCommParamsSpec *tmpSpec = (HcfEccCommParamsSpec *)HcfMalloc(sizeof(HcfEccCommParamsSpec), 0); + if (tmpSpec == NULL) { + LOGE("Failed to allocate dest spec memory"); + return HCF_ERR_MALLOC; + } + if (CopyEccCommonSpec(srcSpec, tmpSpec) != HCF_SUCCESS) { + LOGE("CreateEccCommonSpecImpl error!"); + HcfFree(tmpSpec); + return HCF_INVALID_PARAMS; + } + *destSpec = tmpSpec; + return HCF_SUCCESS; +} \ No newline at end of file diff --git a/frameworks/spi/ecc_key_util_spi.h b/frameworks/spi/ecc_key_util_spi.h new file mode 100644 index 0000000..09c45b9 --- /dev/null +++ b/frameworks/spi/ecc_key_util_spi.h @@ -0,0 +1,29 @@ +/* + * 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 HCF_ECC_KEY_UTIL_SPI_H +#define HCF_ECC_KEY_UTIL_SPI_H + +#include +#include "result.h" +#include "detailed_ecc_key_params.h" + +typedef struct HcfEccCommParamsSpecSpi HcfEccCommParamsSpecSpi; + +struct HcfEccCommParamsSpecSpi { + HcfEccCommParamsSpec paramsSpec; +}; + +#endif diff --git a/frameworks/spi/signature_spi.h b/frameworks/spi/signature_spi.h index f1cb9d2..68e4c12 100644 --- a/frameworks/spi/signature_spi.h +++ b/frameworks/spi/signature_spi.h @@ -43,6 +43,8 @@ struct HcfSignSpi { HcfResult (*engineGetSignSpecString)(HcfSignSpi *self, SignSpecItem item, char **returnString); HcfResult (*engineGetSignSpecInt)(HcfSignSpi *self, SignSpecItem item, int32_t *returnInt); + + HcfResult (*engineSetSignSpecUint8Array)(HcfSignSpi *self, SignSpecItem item, HcfBlob blob); }; typedef struct HcfVerifySpi HcfVerifySpi; @@ -61,6 +63,8 @@ struct HcfVerifySpi { HcfResult (*engineGetVerifySpecString)(HcfVerifySpi *self, SignSpecItem item, char **returnString); HcfResult (*engineGetVerifySpecInt)(HcfVerifySpi *self, SignSpecItem item, int32_t *returnInt); + + HcfResult (*engineSetVerifySpecUint8Array)(HcfVerifySpi *self, SignSpecItem item, HcfBlob blob); }; #endif diff --git a/interfaces/innerkits/common/result.h b/interfaces/innerkits/common/result.h index 38de2d6..9e2a576 100644 --- a/interfaces/innerkits/common/result.h +++ b/interfaces/innerkits/common/result.h @@ -25,7 +25,7 @@ typedef enum HcfResult { HCF_NOT_SUPPORT = -10002, /** Indicates that memory malloc fails. */ - HCF_ERR_MALLOC = -20001, + HCF_ERR_MALLOC = 20001, /** Indicates that memory copy fails. */ HCF_ERR_COPY = -20002, diff --git a/interfaces/innerkits/crypto_operation/cipher.h b/interfaces/innerkits/crypto_operation/cipher.h index ea2ed43..e3dc0c3 100644 --- a/interfaces/innerkits/crypto_operation/cipher.h +++ b/interfaces/innerkits/crypto_operation/cipher.h @@ -41,6 +41,7 @@ typedef enum { OAEP_MGF_NAME_STR = 101, OAEP_MGF1_MD_STR = 102, OAEP_MGF1_PSRC_UINT8ARR = 103, + SM2_MD_NAME_STR = 104 } CipherSpecItem; typedef struct HcfCipher HcfCipher; @@ -63,7 +64,7 @@ struct HcfCipher { const char *(*getAlgorithm)(HcfCipher *self); - HcfResult (*setCipherSpecUint8Array)(HcfCipher *self, CipherSpecItem item, HcfBlob pSource); + HcfResult (*setCipherSpecUint8Array)(HcfCipher *self, CipherSpecItem item, HcfBlob blob); HcfResult (*getCipherSpecString)(HcfCipher *self, CipherSpecItem item, char **returnString); diff --git a/interfaces/innerkits/crypto_operation/signature.h b/interfaces/innerkits/crypto_operation/signature.h index 9186904..5646261 100644 --- a/interfaces/innerkits/crypto_operation/signature.h +++ b/interfaces/innerkits/crypto_operation/signature.h @@ -28,6 +28,7 @@ typedef enum { PSS_MGF1_MD_STR = 102, PSS_SALT_LEN_INT = 103, // warning: PSS_SALT_LEN_NUM in JS PSS_TRAILER_FIELD_INT = 104, // warning: PSS_TRAILER_FIELD_NUM in JS + SM2_USER_ID_UINT8ARR = 105 } SignSpecItem; typedef struct HcfSign HcfSign; @@ -48,6 +49,8 @@ struct HcfSign { HcfResult (*getSignSpecString)(HcfSign *self, SignSpecItem item, char **returnString); HcfResult (*getSignSpecInt)(HcfSign *self, SignSpecItem item, int32_t *returnInt); + + HcfResult (*setSignSpecUint8Array)(HcfSign *self, SignSpecItem item, HcfBlob blob); }; typedef struct HcfVerify HcfVerify; @@ -68,6 +71,8 @@ struct HcfVerify { HcfResult (*getVerifySpecString)(HcfVerify *self, SignSpecItem item, char **returnString); HcfResult (*getVerifySpecInt)(HcfVerify *self, SignSpecItem item, int32_t *returnInt); + + HcfResult (*setVerifySpecUint8Array)(HcfVerify *self, SignSpecItem item, HcfBlob blob); }; #ifdef __cplusplus diff --git a/interfaces/innerkits/key/ecc_key_util.h b/interfaces/innerkits/key/ecc_key_util.h new file mode 100644 index 0000000..782d785 --- /dev/null +++ b/interfaces/innerkits/key/ecc_key_util.h @@ -0,0 +1,33 @@ +/* + * 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 HCF_ECC_KEY_UTIL_H +#define HCF_ECC_KEY_UTIL_H + +#include +#include "result.h" +#include "detailed_ecc_key_params.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult HcfEccKeyUtilCreate(const char *algName, HcfEccCommParamsSpec **returnCommonParamSpec); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/interfaces/innerkits/key/key_utils.h b/interfaces/innerkits/key/key_utils.h new file mode 100644 index 0000000..f327329 --- /dev/null +++ b/interfaces/innerkits/key/key_utils.h @@ -0,0 +1,41 @@ +/* + * 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 HCF_KEY_UTILS_H +#define HCF_KEY_UTILS_H + +#include +#include "result.h" +#include "detailed_ecc_key_params.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult CopyAsyKeyParamsSpec(const HcfAsyKeyParamsSpec *srcSpec, HcfAsyKeyParamsSpec *destSpec); + +HcfResult CopyPoint(const HcfPoint *src, HcfPoint *dest); + +HcfResult CopyEcField(const HcfECField *src, HcfECField **dest); + +HcfResult CopyEccCommonSpec(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec *destSpec); + +HcfResult CreateEccCommonSpecImpl(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec **destSpec); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/plugin/openssl_plugin/common/inc/ecc_openssl_common.h b/plugin/openssl_plugin/common/inc/ecc_openssl_common.h index 8d200ff..964508c 100644 --- a/plugin/openssl_plugin/common/inc/ecc_openssl_common.h +++ b/plugin/openssl_plugin/common/inc/ecc_openssl_common.h @@ -22,6 +22,20 @@ static const int32_t NID_secp224r1_len = 28; static const int32_t NID_X9_62_prime256v1_len = 32; static const int32_t NID_secp384r1_len = 48; static const int32_t NID_secp521r1_len = 66; +static const int32_t NID_brainpoolP160r1_len = 20; +static const int32_t NID_brainpoolP160t1_len = 20; +static const int32_t NID_brainpoolP192r1_len = 24; +static const int32_t NID_brainpoolP192t1_len = 24; +static const int32_t NID_brainpoolP224r1_len = 28; +static const int32_t NID_brainpoolP224t1_len = 28; +static const int32_t NID_brainpoolP256r1_len = 32; +static const int32_t NID_brainpoolP256t1_len = 32; +static const int32_t NID_brainpoolP320r1_len = 40; +static const int32_t NID_brainpoolP320t1_len = 40; +static const int32_t NID_brainpoolP384r1_len = 48; +static const int32_t NID_brainpoolP384t1_len = 48; +static const int32_t NID_brainpoolP512r1_len = 64; +static const int32_t NID_brainpoolP512t1_len = 64; static unsigned char g_ecc224CorrectBigP[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, @@ -138,4 +152,402 @@ static unsigned char g_ecc521CorrectBigGY[] = { 0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50 }; +// SM2_256 +static unsigned char g_sm256CorrectBigP[] = { + 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff +}; + +static unsigned char g_sm256CorrectBigB[] = { + 0x28, 0xe9, 0xfa, 0x9e, 0x9d, 0x9f, 0x5e, 0x34, 0x4d, 0x5a, 0x9e, 0x4b, + 0xcf, 0x65, 0x09, 0xa7, 0xf3, 0x97, 0x89, 0xf5, 0x15, 0xab, 0x8f, 0x92, + 0xdd, 0xbc, 0xbd, 0x41, 0x4d, 0x94, 0x0e, 0x93, +}; + +static unsigned char g_sm256CorrectBigGX[] = { + 0x32, 0xc4, 0xae, 0x2c, 0x1f, 0x19, 0x81, 0x19, 0x5f, 0x99, 0x04, 0x46, + 0x6a, 0x39, 0xc9, 0x94, 0x8f, 0xe3, 0x0b, 0xbf, 0xf2, 0x66, 0x0b, 0xe1, + 0x71, 0x5a, 0x45, 0x89, 0x33, 0x4c, 0x74, 0xc7 +}; + +static unsigned char g_sm256CorrectBigGY[] = { + 0xbc, 0x37, 0x36, 0xa2, 0xf4, 0xf6, 0x77, 0x9c, 0x59, 0xbd, 0xce, 0xe3, + 0x6b, 0x69, 0x21, 0x53, 0xd0, 0xa9, 0x87, 0x7c, 0xc6, 0x2a, 0x47, 0x40, + 0x02, 0xdf, 0x32, 0xe5, 0x21, 0x39, 0xf0, 0xa0 +}; + +// BrainPool160r1 +static unsigned char g_bp160r1CorrectBigP[] = { + 0xE9, 0x5E, 0x4A, 0x5F, 0x73, 0x70, 0x59, 0xDC, 0x60, 0xDF, 0xC7, 0xAD, + 0x95, 0xB3, 0xD8, 0x13, 0x95, 0x15, 0x62, 0x0F +}; + +static unsigned char g_bp160r1CorrectBigB[] = { + 0x1E, 0x58, 0x9A, 0x85, 0x95, 0x42, 0x34, 0x12, 0x13, 0x4F, 0xAA, 0x2D, + 0xBD, 0xEC, 0x95, 0xC8, 0xD8, 0x67, 0x5E, 0x58 +}; + +static unsigned char g_bp160r1CorrectBigGX[] = { + 0xBE, 0xD5, 0xAF, 0x16, 0xEA, 0x3F, 0x6A, 0x4F, 0x62, 0x93, 0x8C, 0x46, + 0x31, 0xEB, 0x5A, 0xF7, 0xBD, 0xBC, 0xDB, 0xC3 +}; + +static unsigned char g_bp160r1CorrectBigGY[] = { + 0x16, 0x67, 0xCB, 0x47, 0x7A, 0x1A, 0x8E, 0xC3, 0x38, 0xF9, 0x47, 0x41, + 0x66, 0x9C, 0x97, 0x63, 0x16, 0xDA, 0x63, 0x21 +}; + +// BrainPool160t1 +static unsigned char g_bp160t1CorrectBigP[] = { + 0xE9, 0x5E, 0x4A, 0x5F, 0x73, 0x70, 0x59, 0xDC, 0x60, 0xDF, 0xC7, 0xAD, + 0x95, 0xB3, 0xD8, 0x13, 0x95, 0x15, 0x62, 0x0F +}; + +static unsigned char g_bp160t1CorrectBigB[] = { + 0x7A, 0x55, 0x6B, 0x6D, 0xAE, 0x53, 0x5B, 0x7B, 0x51, 0xED, 0x2C, 0x4D, + 0x7D, 0xAA, 0x7A, 0x0B, 0x5C, 0x55, 0xF3, 0x80 +}; + +static unsigned char g_bp160t1CorrectBigGX[] = { + 0xB1, 0x99, 0xB1, 0x3B, 0x9B, 0x34, 0xEF, 0xC1, 0x39, 0x7E, 0x64, 0xBA, + 0xEB, 0x05, 0xAC, 0xC2, 0x65, 0xFF, 0x23, 0x78 +}; + +static unsigned char g_bp160t1CorrectBigGY[] = { + 0xAD, 0xD6, 0x71, 0x8B, 0x7C, 0x7C, 0x19, 0x61, 0xF0, 0x99, 0x1B, 0x84, + 0x24, 0x43, 0x77, 0x21, 0x52, 0xC9, 0xE0, 0xAD +}; + +// BrainPool192r1 +static unsigned char g_bp192r1CorrectBigP[] = { + 0xC3, 0x02, 0xF4, 0x1D, 0x93, 0x2A, 0x36, 0xCD, 0xA7, 0xA3, 0x46, 0x30, + 0x93, 0xD1, 0x8D, 0xB7, 0x8F, 0xCE, 0x47, 0x6D, 0xE1, 0xA8, 0x62, 0x97 +}; + +static unsigned char g_bp192r1CorrectBigB[] = { + 0x46, 0x9A, 0x28, 0xEF, 0x7C, 0x28, 0xCC, 0xA3, 0xDC, 0x72, 0x1D, 0x04, + 0x4F, 0x44, 0x96, 0xBC, 0xCA, 0x7E, 0xF4, 0x14, 0x6F, 0xBF, 0x25, 0xC9 +}; + +static unsigned char g_bp192r1CorrectBigGX[] = { + 0xC0, 0xA0, 0x64, 0x7E, 0xAA, 0xB6, 0xA4, 0x87, 0x53, 0xB0, 0x33, 0xC5, + 0x6C, 0xB0, 0xF0, 0x90, 0x0A, 0x2F, 0x5C, 0x48, 0x53, 0x37, 0x5F, 0xD6 +}; + +static unsigned char g_bp192r1CorrectBigGY[] = { + 0x14, 0xB6, 0x90, 0x86, 0x6A, 0xBD, 0x5B, 0xB8, 0x8B, 0x5F, 0x48, 0x28, + 0xC1, 0x49, 0x00, 0x02, 0xE6, 0x77, 0x3F, 0xA2, 0xFA, 0x29, 0x9B, 0x8F +}; + +// BrainPool192t1 +static unsigned char g_bp192t1CorrectBigP[] = { + 0xC3, 0x02, 0xF4, 0x1D, 0x93, 0x2A, 0x36, 0xCD, 0xA7, 0xA3, 0x46, 0x30, + 0x93, 0xD1, 0x8D, 0xB7, 0x8F, 0xCE, 0x47, 0x6D, 0xE1, 0xA8, 0x62, 0x97 +}; + +static unsigned char g_bp192t1CorrectBigB[] = { + 0x13, 0xD5, 0x6F, 0xFA, 0xEC, 0x78, 0x68, 0x1E, 0x68, 0xF9, 0xDE, 0xB4, + 0x3B, 0x35, 0xBE, 0xC2, 0xFB, 0x68, 0x54, 0x2E, 0x27, 0x89, 0x7B, 0x79 +}; + +static unsigned char g_bp192t1CorrectBigGX[] = { + 0x3A, 0xE9, 0xE5, 0x8C, 0x82, 0xF6, 0x3C, 0x30, 0x28, 0x2E, 0x1F, 0xE7, + 0xBB, 0xF4, 0x3F, 0xA7, 0x2C, 0x44, 0x6A, 0xF6, 0xF4, 0x61, 0x81, 0x29 +}; + +static unsigned char g_bp192t1CorrectBigGY[] = { + 0x09, 0x7E, 0x2C, 0x56, 0x67, 0xC2, 0x22, 0x3A, 0x90, 0x2A, 0xB5, 0xCA, + 0x44, 0x9D, 0x00, 0x84, 0xB7, 0xE5, 0xB3, 0xDE, 0x7C, 0xCC, 0x01, 0xC9 +}; + +// BrainPool224r1 +static unsigned char g_bp224r1CorrectBigP[] = { + 0xD7, 0xC1, 0x34, 0xAA, 0x26, 0x43, 0x66, 0x86, 0x2A, 0x18, 0x30, 0x25, + 0x75, 0xD1, 0xD7, 0x87, 0xB0, 0x9F, 0x07, 0x57, 0x97, 0xDA, 0x89, 0xF5, + 0x7E, 0xC8, 0xC0, 0xFF +}; + +static unsigned char g_bp224r1CorrectBigB[] = { + 0x25, 0x80, 0xF6, 0x3C, 0xCF, 0xE4, 0x41, 0x38, 0x87, 0x07, 0x13, 0xB1, + 0xA9, 0x23, 0x69, 0xE3, 0x3E, 0x21, 0x35, 0xD2, 0x66, 0xDB, 0xB3, 0x72, + 0x38, 0x6C, 0x40, 0x0B +}; + +static unsigned char g_bp224r1CorrectBigGX[] = { + 0x0D, 0x90, 0x29, 0xAD, 0x2C, 0x7E, 0x5C, 0xF4, 0x34, 0x08, 0x23, 0xB2, + 0xA8, 0x7D, 0xC6, 0x8C, 0x9E, 0x4C, 0xE3, 0x17, 0x4C, 0x1E, 0x6E, 0xFD, + 0xEE, 0x12, 0xC0, 0x7D +}; + +static unsigned char g_bp224r1CorrectBigGY[] = { + 0x58, 0xAA, 0x56, 0xF7, 0x72, 0xC0, 0x72, 0x6F, 0x24, 0xC6, 0xB8, 0x9E, + 0x4E, 0xCD, 0xAC, 0x24, 0x35, 0x4B, 0x9E, 0x99, 0xCA, 0xA3, 0xF6, 0xD3, + 0x76, 0x14, 0x02, 0xCD +}; + +// BrainPool224t1 +static unsigned char g_bp224t1CorrectBigP[] = { + 0xD7, 0xC1, 0x34, 0xAA, 0x26, 0x43, 0x66, 0x86, 0x2A, 0x18, 0x30, 0x25, + 0x75, 0xD1, 0xD7, 0x87, 0xB0, 0x9F, 0x07, 0x57, 0x97, 0xDA, 0x89, 0xF5, + 0x7E, 0xC8, 0xC0, 0xFF +}; + +static unsigned char g_bp224t1CorrectBigB[] = { + 0x4B, 0x33, 0x7D, 0x93, 0x41, 0x04, 0xCD, 0x7B, 0xEF, 0x27, 0x1B, 0xF6, + 0x0C, 0xED, 0x1E, 0xD2, 0x0D, 0xA1, 0x4C, 0x08, 0xB3, 0xBB, 0x64, 0xF1, + 0x8A, 0x60, 0x88, 0x8D +}; + +static unsigned char g_bp224t1CorrectBigGX[] = { + 0x6A, 0xB1, 0xE3, 0x44, 0xCE, 0x25, 0xFF, 0x38, 0x96, 0x42, 0x4E, 0x7F, + 0xFE, 0x14, 0x76, 0x2E, 0xCB, 0x49, 0xF8, 0x92, 0x8A, 0xC0, 0xC7, 0x60, + 0x29, 0xB4, 0xD5, 0x80 +}; + +static unsigned char g_bp224t1CorrectBigGY[] = { + 0x03, 0x74, 0xE9, 0xF5, 0x14, 0x3E, 0x56, 0x8C, 0xD2, 0x3F, 0x3F, 0x4D, + 0x7C, 0x0D, 0x4B, 0x1E, 0x41, 0xC8, 0xCC, 0x0D, 0x1C, 0x6A, 0xBD, 0x5F, + 0x1A, 0x46, 0xDB, 0x4C +}; + +// BrainPool256r1 +static unsigned char g_bp256r1CorrectBigP[] = { + 0xA9, 0xFB, 0x57, 0xDB, 0xA1, 0xEE, 0xA9, 0xBC, 0x3E, 0x66, 0x0A, 0x90, + 0x9D, 0x83, 0x8D, 0x72, 0x6E, 0x3B, 0xF6, 0x23, 0xD5, 0x26, 0x20, 0x28, + 0x20, 0x13, 0x48, 0x1D, 0x1F, 0x6E, 0x53, 0x77 +}; + +static unsigned char g_bp256r1CorrectBigB[] = { + 0x26, 0xDC, 0x5C, 0x6C, 0xE9, 0x4A, 0x4B, 0x44, 0xF3, 0x30, 0xB5, 0xD9, + 0xBB, 0xD7, 0x7C, 0xBF, 0x95, 0x84, 0x16, 0x29, 0x5C, 0xF7, 0xE1, 0xCE, + 0x6B, 0xCC, 0xDC, 0x18, 0xFF, 0x8C, 0x07, 0xB6 +}; + +static unsigned char g_bp256r1CorrectBigGX[] = { + 0x8B, 0xD2, 0xAE, 0xB9, 0xCB, 0x7E, 0x57, 0xCB, 0x2C, 0x4B, 0x48, 0x2F, + 0xFC, 0x81, 0xB7, 0xAF, 0xB9, 0xDE, 0x27, 0xE1, 0xE3, 0xBD, 0x23, 0xC2, + 0x3A, 0x44, 0x53, 0xBD, 0x9A, 0xCE, 0x32, 0x62 +}; + +static unsigned char g_bp256r1CorrectBigGY[] = { + 0x54, 0x7E, 0xF8, 0x35, 0xC3, 0xDA, 0xC4, 0xFD, 0x97, 0xF8, 0x46, 0x1A, + 0x14, 0x61, 0x1D, 0xC9, 0xC2, 0x77, 0x45, 0x13, 0x2D, 0xED, 0x8E, 0x54, + 0x5C, 0x1D, 0x54, 0xC7, 0x2F, 0x04, 0x69, 0x97 +}; + +// BrainPool256t1 +static unsigned char g_bp256t1CorrectBigP[] = { + 0xA9, 0xFB, 0x57, 0xDB, 0xA1, 0xEE, 0xA9, 0xBC, 0x3E, 0x66, 0x0A, 0x90, + 0x9D, 0x83, 0x8D, 0x72, 0x6E, 0x3B, 0xF6, 0x23, 0xD5, 0x26, 0x20, 0x28, + 0x20, 0x13, 0x48, 0x1D, 0x1F, 0x6E, 0x53, 0x77 +}; + +static unsigned char g_bp256t1CorrectBigB[] = { + 0x66, 0x2C, 0x61, 0xC4, 0x30, 0xD8, 0x4E, 0xA4, 0xFE, 0x66, 0xA7, 0x73, + 0x3D, 0x0B, 0x76, 0xB7, 0xBF, 0x93, 0xEB, 0xC4, 0xAF, 0x2F, 0x49, 0x25, + 0x6A, 0xE5, 0x81, 0x01, 0xFE, 0xE9, 0x2B, 0x04 +}; + +static unsigned char g_bp256t1CorrectBigGX[] = { + 0xA3, 0xE8, 0xEB, 0x3C, 0xC1, 0xCF, 0xE7, 0xB7, 0x73, 0x22, 0x13, 0xB2, + 0x3A, 0x65, 0x61, 0x49, 0xAF, 0xA1, 0x42, 0xC4, 0x7A, 0xAF, 0xBC, 0x2B, + 0x79, 0xA1, 0x91, 0x56, 0x2E, 0x13, 0x05, 0xF4 +}; + +static unsigned char g_bp256t1CorrectBigGY[] = { + 0x2D, 0x99, 0x6C, 0x82, 0x34, 0x39, 0xC5, 0x6D, 0x7F, 0x7B, 0x22, 0xE1, + 0x46, 0x44, 0x41, 0x7E, 0x69, 0xBC, 0xB6, 0xDE, 0x39, 0xD0, 0x27, 0x00, + 0x1D, 0xAB, 0xE8, 0xF3, 0x5B, 0x25, 0xC9, 0xBE +}; + +// BrainPool320r1 +static unsigned char g_bp320r1CorrectBigP[] = { + 0xD3, 0x5E, 0x47, 0x20, 0x36, 0xBC, 0x4F, 0xB7, 0xE1, 0x3C, 0x78, 0x5E, + 0xD2, 0x01, 0xE0, 0x65, 0xF9, 0x8F, 0xCF, 0xA6, 0xF6, 0xF4, 0x0D, 0xEF, + 0x4F, 0x92, 0xB9, 0xEC, 0x78, 0x93, 0xEC, 0x28, 0xFC, 0xD4, 0x12, 0xB1, + 0xF1, 0xB3, 0x2E, 0x27 +}; + +static unsigned char g_bp320r1CorrectBigB[] = { + 0x52, 0x08, 0x83, 0x94, 0x9D, 0xFD, 0xBC, 0x42, 0xD3, 0xAD, 0x19, 0x86, + 0x40, 0x68, 0x8A, 0x6F, 0xE1, 0x3F, 0x41, 0x34, 0x95, 0x54, 0xB4, 0x9A, + 0xCC, 0x31, 0xDC, 0xCD, 0x88, 0x45, 0x39, 0x81, 0x6F, 0x5E, 0xB4, 0xAC, + 0x8F, 0xB1, 0xF1, 0xA6 +}; + +static unsigned char g_bp320r1CorrectBigGX[] = { + 0x43, 0xBD, 0x7E, 0x9A, 0xFB, 0x53, 0xD8, 0xB8, 0x52, 0x89, 0xBC, 0xC4, + 0x8E, 0xE5, 0xBF, 0xE6, 0xF2, 0x01, 0x37, 0xD1, 0x0A, 0x08, 0x7E, 0xB6, + 0xE7, 0x87, 0x1E, 0x2A, 0x10, 0xA5, 0x99, 0xC7, 0x10, 0xAF, 0x8D, 0x0D, + 0x39, 0xE2, 0x06, 0x11 +}; + +static unsigned char g_bp320r1CorrectBigGY[] = { + 0x14, 0xFD, 0xD0, 0x55, 0x45, 0xEC, 0x1C, 0xC8, 0xAB, 0x40, 0x93, 0x24, + 0x7F, 0x77, 0x27, 0x5E, 0x07, 0x43, 0xFF, 0xED, 0x11, 0x71, 0x82, 0xEA, + 0xA9, 0xC7, 0x78, 0x77, 0xAA, 0xAC, 0x6A, 0xC7, 0xD3, 0x52, 0x45, 0xD1, + 0x69, 0x2E, 0x8E, 0xE1 +}; + +// BrainPool320t1 +static unsigned char g_bp320t1CorrectBigP[] = { + 0xD3, 0x5E, 0x47, 0x20, 0x36, 0xBC, 0x4F, 0xB7, 0xE1, 0x3C, 0x78, 0x5E, + 0xD2, 0x01, 0xE0, 0x65, 0xF9, 0x8F, 0xCF, 0xA6, 0xF6, 0xF4, 0x0D, 0xEF, + 0x4F, 0x92, 0xB9, 0xEC, 0x78, 0x93, 0xEC, 0x28, 0xFC, 0xD4, 0x12, 0xB1, + 0xF1, 0xB3, 0x2E, 0x27 +}; + +static unsigned char g_bp320t1CorrectBigB[] = { + 0xA7, 0xF5, 0x61, 0xE0, 0x38, 0xEB, 0x1E, 0xD5, 0x60, 0xB3, 0xD1, 0x47, + 0xDB, 0x78, 0x20, 0x13, 0x06, 0x4C, 0x19, 0xF2, 0x7E, 0xD2, 0x7C, 0x67, + 0x80, 0xAA, 0xF7, 0x7F, 0xB8, 0xA5, 0x47, 0xCE, 0xB5, 0xB4, 0xFE, 0xF4, + 0x22, 0x34, 0x03, 0x53 +}; + +static unsigned char g_bp320t1CorrectBigGX[] = { + 0x92, 0x5B, 0xE9, 0xFB, 0x01, 0xAF, 0xC6, 0xFB, 0x4D, 0x3E, 0x7D, 0x49, + 0x90, 0x01, 0x0F, 0x81, 0x34, 0x08, 0xAB, 0x10, 0x6C, 0x4F, 0x09, 0xCB, + 0x7E, 0xE0, 0x78, 0x68, 0xCC, 0x13, 0x6F, 0xFF, 0x33, 0x57, 0xF6, 0x24, + 0xA2, 0x1B, 0xED, 0x52 +}; + +static unsigned char g_bp320t1CorrectBigGY[] = { + 0x63, 0xBA, 0x3A, 0x7A, 0x27, 0x48, 0x3E, 0xBF, 0x66, 0x71, 0xDB, 0xEF, + 0x7A, 0xBB, 0x30, 0xEB, 0xEE, 0x08, 0x4E, 0x58, 0xA0, 0xB0, 0x77, 0xAD, + 0x42, 0xA5, 0xA0, 0x98, 0x9D, 0x1E, 0xE7, 0x1B, 0x1B, 0x9B, 0xC0, 0x45, + 0x5F, 0xB0, 0xD2, 0xC3 +}; + +// BrainPool384r1 +static unsigned char g_bp384r1CorrectBigP[] = { + 0x8C, 0xB9, 0x1E, 0x82, 0xA3, 0x38, 0x6D, 0x28, 0x0F, 0x5D, 0x6F, 0x7E, + 0x50, 0xE6, 0x41, 0xDF, 0x15, 0x2F, 0x71, 0x09, 0xED, 0x54, 0x56, 0xB4, + 0x12, 0xB1, 0xDA, 0x19, 0x7F, 0xB7, 0x11, 0x23, 0xAC, 0xD3, 0xA7, 0x29, + 0x90, 0x1D, 0x1A, 0x71, 0x87, 0x47, 0x00, 0x13, 0x31, 0x07, 0xEC, 0x53 +}; + +static unsigned char g_bp384r1CorrectBigB[] = { + 0x04, 0xA8, 0xC7, 0xDD, 0x22, 0xCE, 0x28, 0x26, 0x8B, 0x39, 0xB5, 0x54, + 0x16, 0xF0, 0x44, 0x7C, 0x2F, 0xB7, 0x7D, 0xE1, 0x07, 0xDC, 0xD2, 0xA6, + 0x2E, 0x88, 0x0E, 0xA5, 0x3E, 0xEB, 0x62, 0xD5, 0x7C, 0xB4, 0x39, 0x02, + 0x95, 0xDB, 0xC9, 0x94, 0x3A, 0xB7, 0x86, 0x96, 0xFA, 0x50, 0x4C, 0x11 +}; + +static unsigned char g_bp384r1CorrectBigGX[] = { + 0x1D, 0x1C, 0x64, 0xF0, 0x68, 0xCF, 0x45, 0xFF, 0xA2, 0xA6, 0x3A, 0x81, + 0xB7, 0xC1, 0x3F, 0x6B, 0x88, 0x47, 0xA3, 0xE7, 0x7E, 0xF1, 0x4F, 0xE3, + 0xDB, 0x7F, 0xCA, 0xFE, 0x0C, 0xBD, 0x10, 0xE8, 0xE8, 0x26, 0xE0, 0x34, + 0x36, 0xD6, 0x46, 0xAA, 0xEF, 0x87, 0xB2, 0xE2, 0x47, 0xD4, 0xAF, 0x1E +}; + +static unsigned char g_bp384r1CorrectBigGY[] = { + 0x8A, 0xBE, 0x1D, 0x75, 0x20, 0xF9, 0xC2, 0xA4, 0x5C, 0xB1, 0xEB, 0x8E, + 0x95, 0xCF, 0xD5, 0x52, 0x62, 0xB7, 0x0B, 0x29, 0xFE, 0xEC, 0x58, 0x64, + 0xE1, 0x9C, 0x05, 0x4F, 0xF9, 0x91, 0x29, 0x28, 0x0E, 0x46, 0x46, 0x21, + 0x77, 0x91, 0x81, 0x11, 0x42, 0x82, 0x03, 0x41, 0x26, 0x3C, 0x53, 0x15 +}; + +// BrainPool384t1 +static unsigned char g_bp384t1CorrectBigP[] = { + 0x8C, 0xB9, 0x1E, 0x82, 0xA3, 0x38, 0x6D, 0x28, 0x0F, 0x5D, 0x6F, 0x7E, + 0x50, 0xE6, 0x41, 0xDF, 0x15, 0x2F, 0x71, 0x09, 0xED, 0x54, 0x56, 0xB4, + 0x12, 0xB1, 0xDA, 0x19, 0x7F, 0xB7, 0x11, 0x23, 0xAC, 0xD3, 0xA7, 0x29, + 0x90, 0x1D, 0x1A, 0x71, 0x87, 0x47, 0x00, 0x13, 0x31, 0x07, 0xEC, 0x53 +}; + +static unsigned char g_bp384t1CorrectBigB[] = { + 0x7F, 0x51, 0x9E, 0xAD, 0xA7, 0xBD, 0xA8, 0x1B, 0xD8, 0x26, 0xDB, 0xA6, + 0x47, 0x91, 0x0F, 0x8C, 0x4B, 0x93, 0x46, 0xED, 0x8C, 0xCD, 0xC6, 0x4E, + 0x4B, 0x1A, 0xBD, 0x11, 0x75, 0x6D, 0xCE, 0x1D, 0x20, 0x74, 0xAA, 0x26, + 0x3B, 0x88, 0x80, 0x5C, 0xED, 0x70, 0x35, 0x5A, 0x33, 0xB4, 0x71, 0xEE +}; + +static unsigned char g_bp384t1CorrectBigGX[] = { + 0x18, 0xDE, 0x98, 0xB0, 0x2D, 0xB9, 0xA3, 0x06, 0xF2, 0xAF, 0xCD, 0x72, + 0x35, 0xF7, 0x2A, 0x81, 0x9B, 0x80, 0xAB, 0x12, 0xEB, 0xD6, 0x53, 0x17, + 0x24, 0x76, 0xFE, 0xCD, 0x46, 0x2A, 0xAB, 0xFF, 0xC4, 0xFF, 0x19, 0x1B, + 0x94, 0x6A, 0x5F, 0x54, 0xD8, 0xD0, 0xAA, 0x2F, 0x41, 0x88, 0x08, 0xCC +}; + +static unsigned char g_bp384t1CorrectBigGY[] = { + 0x25, 0xAB, 0x05, 0x69, 0x62, 0xD3, 0x06, 0x51, 0xA1, 0x14, 0xAF, 0xD2, + 0x75, 0x5A, 0xD3, 0x36, 0x74, 0x7F, 0x93, 0x47, 0x5B, 0x7A, 0x1F, 0xCA, + 0x3B, 0x88, 0xF2, 0xB6, 0xA2, 0x08, 0xCC, 0xFE, 0x46, 0x94, 0x08, 0x58, + 0x4D, 0xC2, 0xB2, 0x91, 0x26, 0x75, 0xBF, 0x5B, 0x9E, 0x58, 0x29, 0x28 +}; + +// BrainPool512r1 +static unsigned char g_bp512r1CorrectBigP[] = { + 0xAA, 0xDD, 0x9D, 0xB8, 0xDB, 0xE9, 0xC4, 0x8B, 0x3F, 0xD4, 0xE6, 0xAE, + 0x33, 0xC9, 0xFC, 0x07, 0xCB, 0x30, 0x8D, 0xB3, 0xB3, 0xC9, 0xD2, 0x0E, + 0xD6, 0x63, 0x9C, 0xCA, 0x70, 0x33, 0x08, 0x71, 0x7D, 0x4D, 0x9B, 0x00, + 0x9B, 0xC6, 0x68, 0x42, 0xAE, 0xCD, 0xA1, 0x2A, 0xE6, 0xA3, 0x80, 0xE6, + 0x28, 0x81, 0xFF, 0x2F, 0x2D, 0x82, 0xC6, 0x85, 0x28, 0xAA, 0x60, 0x56, + 0x58, 0x3A, 0x48, 0xF3 +}; + +static unsigned char g_bp512r1CorrectBigB[] = { + 0x3D, 0xF9, 0x16, 0x10, 0xA8, 0x34, 0x41, 0xCA, 0xEA, 0x98, 0x63, 0xBC, + 0x2D, 0xED, 0x5D, 0x5A, 0xA8, 0x25, 0x3A, 0xA1, 0x0A, 0x2E, 0xF1, 0xC9, + 0x8B, 0x9A, 0xC8, 0xB5, 0x7F, 0x11, 0x17, 0xA7, 0x2B, 0xF2, 0xC7, 0xB9, + 0xE7, 0xC1, 0xAC, 0x4D, 0x77, 0xFC, 0x94, 0xCA, 0xDC, 0x08, 0x3E, 0x67, + 0x98, 0x40, 0x50, 0xB7, 0x5E, 0xBA, 0xE5, 0xDD, 0x28, 0x09, 0xBD, 0x63, + 0x80, 0x16, 0xF7, 0x23 +}; + +static unsigned char g_bp512r1CorrectBigGX[] = { + 0x81, 0xAE, 0xE4, 0xBD, 0xD8, 0x2E, 0xD9, 0x64, 0x5A, 0x21, 0x32, 0x2E, + 0x9C, 0x4C, 0x6A, 0x93, 0x85, 0xED, 0x9F, 0x70, 0xB5, 0xD9, 0x16, 0xC1, + 0xB4, 0x3B, 0x62, 0xEE, 0xF4, 0xD0, 0x09, 0x8E, 0xFF, 0x3B, 0x1F, 0x78, + 0xE2, 0xD0, 0xD4, 0x8D, 0x50, 0xD1, 0x68, 0x7B, 0x93, 0xB9, 0x7D, 0x5F, + 0x7C, 0x6D, 0x50, 0x47, 0x40, 0x6A, 0x5E, 0x68, 0x8B, 0x35, 0x22, 0x09, + 0xBC, 0xB9, 0xF8, 0x22 +}; + +static unsigned char g_bp512r1CorrectBigGY[] = { + 0x7D, 0xDE, 0x38, 0x5D, 0x56, 0x63, 0x32, 0xEC, 0xC0, 0xEA, 0xBF, 0xA9, + 0xCF, 0x78, 0x22, 0xFD, 0xF2, 0x09, 0xF7, 0x00, 0x24, 0xA5, 0x7B, 0x1A, + 0xA0, 0x00, 0xC5, 0x5B, 0x88, 0x1F, 0x81, 0x11, 0xB2, 0xDC, 0xDE, 0x49, + 0x4A, 0x5F, 0x48, 0x5E, 0x5B, 0xCA, 0x4B, 0xD8, 0x8A, 0x27, 0x63, 0xAE, + 0xD1, 0xCA, 0x2B, 0x2F, 0xA8, 0xF0, 0x54, 0x06, 0x78, 0xCD, 0x1E, 0x0F, + 0x3A, 0xD8, 0x08, 0x92 +}; + +// BrainPool512t1 +static unsigned char g_bp512t1CorrectBigP[] = { + 0xAA, 0xDD, 0x9D, 0xB8, 0xDB, 0xE9, 0xC4, 0x8B, 0x3F, 0xD4, 0xE6, 0xAE, + 0x33, 0xC9, 0xFC, 0x07, 0xCB, 0x30, 0x8D, 0xB3, 0xB3, 0xC9, 0xD2, 0x0E, + 0xD6, 0x63, 0x9C, 0xCA, 0x70, 0x33, 0x08, 0x71, 0x7D, 0x4D, 0x9B, 0x00, + 0x9B, 0xC6, 0x68, 0x42, 0xAE, 0xCD, 0xA1, 0x2A, 0xE6, 0xA3, 0x80, 0xE6, + 0x28, 0x81, 0xFF, 0x2F, 0x2D, 0x82, 0xC6, 0x85, 0x28, 0xAA, 0x60, 0x56, + 0x58, 0x3A, 0x48, 0xF3 +}; + +static unsigned char g_bp512t1CorrectBigB[] = { + 0x7C, 0xBB, 0xBC, 0xF9, 0x44, 0x1C, 0xFA, 0xB7, 0x6E, 0x18, 0x90, 0xE4, + 0x68, 0x84, 0xEA, 0xE3, 0x21, 0xF7, 0x0C, 0x0B, 0xCB, 0x49, 0x81, 0x52, + 0x78, 0x97, 0x50, 0x4B, 0xEC, 0x3E, 0x36, 0xA6, 0x2B, 0xCD, 0xFA, 0x23, + 0x04, 0x97, 0x65, 0x40, 0xF6, 0x45, 0x00, 0x85, 0xF2, 0xDA, 0xE1, 0x45, + 0xC2, 0x25, 0x53, 0xB4, 0x65, 0x76, 0x36, 0x89, 0x18, 0x0E, 0xA2, 0x57, + 0x18, 0x67, 0x42, 0x3E +}; + +static unsigned char g_bp512t1CorrectBigGX[] = { + 0x64, 0x0E, 0xCE, 0x5C, 0x12, 0x78, 0x87, 0x17, 0xB9, 0xC1, 0xBA, 0x06, + 0xCB, 0xC2, 0xA6, 0xFE, 0xBA, 0x85, 0x84, 0x24, 0x58, 0xC5, 0x6D, 0xDE, + 0x9D, 0xB1, 0x75, 0x8D, 0x39, 0xC0, 0x31, 0x3D, 0x82, 0xBA, 0x51, 0x73, + 0x5C, 0xDB, 0x3E, 0xA4, 0x99, 0xAA, 0x77, 0xA7, 0xD6, 0x94, 0x3A, 0x64, + 0xF7, 0xA3, 0xF2, 0x5F, 0xE2, 0x6F, 0x06, 0xB5, 0x1B, 0xAA, 0x26, 0x96, + 0xFA, 0x90, 0x35, 0xDA +}; + +static unsigned char g_bp512t1CorrectBigGY[] = { + 0x5B, 0x53, 0x4B, 0xD5, 0x95, 0xF5, 0xAF, 0x0F, 0xA2, 0xC8, 0x92, 0x37, + 0x6C, 0x84, 0xAC, 0xE1, 0xBB, 0x4E, 0x30, 0x19, 0xB7, 0x16, 0x34, 0xC0, + 0x11, 0x31, 0x15, 0x9C, 0xAE, 0x03, 0xCE, 0xE9, 0xD9, 0x93, 0x21, 0x84, + 0xBE, 0xEF, 0x21, 0x6B, 0xD7, 0x1D, 0xF2, 0xDA, 0xDF, 0x86, 0xA6, 0x27, + 0x30, 0x6E, 0xCF, 0xF9, 0x6D, 0xBB, 0x8B, 0xAC, 0xE1, 0x98, 0xB6, 0x1E, + 0x00, 0xF8, 0xB3, 0x32 +}; #endif diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h index fa9c89b..289d141 100644 --- a/plugin/openssl_plugin/common/inc/openssl_adapter.h +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -68,6 +68,7 @@ void Openssl_EC_POINT_free(EC_POINT *point); EC_GROUP *Openssl_EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); void Openssl_EC_GROUP_free(EC_GROUP *group); EC_POINT *Openssl_EC_POINT_new(const EC_GROUP *group); +int Openssl_EC_POINT_copy(EC_POINT *dst, const EC_POINT *src); int Openssl_EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point, const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx); int Openssl_EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, @@ -91,6 +92,7 @@ int Openssl_EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_sca EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void); void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx); void Openssl_EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx); +EVP_PKEY_CTX *Openssl_EVP_MD_CTX_get_pkey_ctx(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); @@ -264,6 +266,8 @@ int Openssl_sm2_decrypt(const EC_KEY *key, const EVP_MD *digest, const uint8_t * int Openssl_PKCS5_PBKDF2_HMAC(const char *pass, int passlen, const unsigned char *salt, int saltlen, int iter, const EVP_MD *digest, int keylen, unsigned char *out); +EC_GROUP *Openssl_EC_GROUP_new_by_curve_name(int nid); + #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/inc/openssl_class.h b/plugin/openssl_plugin/common/inc/openssl_class.h index fcaf942..4144b72 100644 --- a/plugin/openssl_plugin/common/inc/openssl_class.h +++ b/plugin/openssl_plugin/common/inc/openssl_class.h @@ -101,6 +101,8 @@ typedef struct { int32_t curveId; EC_KEY *ecKey; + + char *fieldType; } HcfOpensslSm2PubKey; #define HCF_OPENSSL_SM2_PUB_KEY_CLASS "OPENSSL.SM2.PUB_KEY" @@ -110,6 +112,8 @@ typedef struct { int32_t curveId; EC_KEY *ecKey; + + char *fieldType; } HcfOpensslSm2PriKey; #define HCF_OPENSSL_SM2_PRI_KEY_CLASS "OPENSSL.SM2.PRI_KEY" diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index 75f27db..5417fe0 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -40,6 +40,8 @@ typedef enum { extern "C" { #endif +HcfResult GetCurveNameByCurveId(int32_t curveId, char **curveName); +HcfResult GetAlgNameByBits(int32_t keyLen, char **algName); HcfResult GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId); HcfResult GetOpensslDigestAlg(uint32_t alg, EVP_MD **digestAlg); void HcfPrintOpensslError(void); @@ -58,6 +60,8 @@ HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString); HcfResult GetRsaSpecStringMGF(char **returnString); +HcfResult GetSm2SpecStringSm3(char **returnString); + #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c index f4a4d43..d460672 100644 --- a/plugin/openssl_plugin/common/src/openssl_adapter.c +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -203,6 +203,11 @@ EC_POINT *Openssl_EC_POINT_new(const EC_GROUP *group) return EC_POINT_new(group); } +int Openssl_EC_POINT_copy(EC_POINT *dst, const EC_POINT *src) +{ + return EC_POINT_copy(dst, src); +} + int Openssl_EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point, const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx) { @@ -297,6 +302,11 @@ void Openssl_EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx) EVP_MD_CTX_set_pkey_ctx(ctx, pctx); } +EVP_PKEY_CTX *Openssl_EVP_MD_CTX_get_pkey_ctx(EVP_MD_CTX *ctx) +{ + return EVP_MD_CTX_get_pkey_ctx(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); @@ -1045,4 +1055,9 @@ int Openssl_PKCS5_PBKDF2_HMAC(const char *pass, int passlen, const unsigned char int saltlen, int iter, const EVP_MD *digest, int keylen, unsigned char *out) { return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, digest, keylen, out); +} + +EC_GROUP *Openssl_EC_GROUP_new_by_curve_name(int nid) +{ + return EC_GROUP_new_by_curve_name(nid); } \ 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 c4422f2..4aa4403 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -25,6 +25,7 @@ #include "openssl_adapter.h" #include "result.h" #include "params_parser.h" +#include "utils.h" #define PRIMES_2 2 #define PRIMES_3 3 @@ -43,30 +44,146 @@ static const uint32_t ASCII_CODE_ZERO = 48; -HcfResult GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId) +typedef struct { + int32_t bits; // keyLen + int32_t nid; // nid +} NidTypeAlg; + +static const NidTypeAlg NID_TYPE_MAP[] = { + { HCF_ALG_ECC_224, NID_secp224r1 }, + { HCF_ALG_ECC_256, NID_X9_62_prime256v1 }, + { HCF_ALG_ECC_384, NID_secp384r1 }, + { HCF_ALG_ECC_521, NID_secp521r1 }, + { HCF_ALG_SM2_256, NID_sm2 }, + { HCF_ALG_ECC_BP160R1, NID_brainpoolP160r1 }, + { HCF_ALG_ECC_BP160T1, NID_brainpoolP160t1 }, + { HCF_ALG_ECC_BP192R1, NID_brainpoolP192r1 }, + { HCF_ALG_ECC_BP192T1, NID_brainpoolP192t1 }, + { HCF_ALG_ECC_BP224R1, NID_brainpoolP224r1 }, + { HCF_ALG_ECC_BP224T1, NID_brainpoolP224t1 }, + { HCF_ALG_ECC_BP256R1, NID_brainpoolP256r1 }, + { HCF_ALG_ECC_BP256T1, NID_brainpoolP256t1 }, + { HCF_ALG_ECC_BP320R1, NID_brainpoolP320r1 }, + { HCF_ALG_ECC_BP320T1, NID_brainpoolP320t1 }, + { HCF_ALG_ECC_BP384R1, NID_brainpoolP384r1 }, + { HCF_ALG_ECC_BP384T1, NID_brainpoolP384t1 }, + { HCF_ALG_ECC_BP512R1, NID_brainpoolP512r1 }, + { HCF_ALG_ECC_BP512T1, NID_brainpoolP512t1 }, +}; + +typedef struct { + int32_t curveId; + char *curveName; +} CurveNameAlg; + +static const CurveNameAlg CURVE_NAME_MAP[] = { + { NID_secp224r1, "NID_secp224r1" }, + { NID_X9_62_prime256v1, "NID_X9_62_prime256v1" }, + { NID_secp384r1, "NID_secp384r1" }, + { NID_secp521r1, "NID_secp521r1" }, + { NID_brainpoolP160r1, "NID_brainpoolP160r1" }, + { NID_brainpoolP160t1, "NID_brainpoolP160t1" }, + { NID_brainpoolP192r1, "NID_brainpoolP192r1" }, + { NID_brainpoolP192t1, "NID_brainpoolP192t1" }, + { NID_brainpoolP224r1, "NID_brainpoolP224r1" }, + { NID_brainpoolP224t1, "NID_brainpoolP224t1" }, + { NID_brainpoolP256r1, "NID_brainpoolP256r1" }, + { NID_brainpoolP256t1, "NID_brainpoolP256t1" }, + { NID_brainpoolP320r1, "NID_brainpoolP320r1" }, + { NID_brainpoolP320t1, "NID_brainpoolP320t1" }, + { NID_brainpoolP384r1, "NID_brainpoolP384r1" }, + { NID_brainpoolP384t1, "NID_brainpoolP384t1" }, + { NID_brainpoolP512r1, "NID_brainpoolP512r1" }, + { NID_brainpoolP512t1, "NID_brainpoolP512t1" } +}; + +typedef struct { + int32_t bits; + char *algName; +} AlgNameType; + +static const AlgNameType ALG_NAME_TYPE_MAP[] = { + { HCF_ALG_ECC_224, "ECC" }, + { HCF_ALG_ECC_256, "ECC" }, + { HCF_ALG_ECC_384, "ECC" }, + { HCF_ALG_ECC_521, "ECC" }, + { HCF_ALG_SM2_256, "SM2" }, + { HCF_ALG_ECC_BP160R1, "ECC" }, + { HCF_ALG_ECC_BP160T1, "ECC" }, + { HCF_ALG_ECC_BP192R1, "ECC" }, + { HCF_ALG_ECC_BP192T1, "ECC" }, + { HCF_ALG_ECC_BP224R1, "ECC" }, + { HCF_ALG_ECC_BP224T1, "ECC" }, + { HCF_ALG_ECC_BP256R1, "ECC" }, + { HCF_ALG_ECC_BP256T1, "ECC" }, + { HCF_ALG_ECC_BP320R1, "ECC" }, + { HCF_ALG_ECC_BP320T1, "ECC" }, + { HCF_ALG_ECC_BP384R1, "ECC" }, + { HCF_ALG_ECC_BP384T1, "ECC" }, + { HCF_ALG_ECC_BP512R1, "ECC" }, + { HCF_ALG_ECC_BP512T1, "ECC" } +}; + +HcfResult GetCurveNameByCurveId(int32_t curveId, char **curveName) { - switch (keyLen) { - case HCF_ALG_ECC_224: - *returnCurveId = NID_secp224r1; - break; - case HCF_ALG_ECC_256: - *returnCurveId = NID_X9_62_prime256v1; - break; - case HCF_ALG_SM2_256: - *returnCurveId = NID_sm2; - break; - case HCF_ALG_ECC_384: - *returnCurveId = NID_secp384r1; - break; - case HCF_ALG_ECC_521: - *returnCurveId = NID_secp521r1; - break; - default: - LOGE("invalid key size."); - return HCF_INVALID_PARAMS; + if (curveName == NULL) { + LOGE("Invalid curveName"); + return HCF_INVALID_PARAMS; + } + for (uint32_t i = 0; i < sizeof(CURVE_NAME_MAP) / sizeof(CURVE_NAME_MAP[0]); i++) { + if (CURVE_NAME_MAP[i].curveId == curveId) { + *curveName = CURVE_NAME_MAP[i].curveName; + return HCF_SUCCESS; + } } + LOGE("invalid key size:%d", curveId); + return HCF_INVALID_PARAMS; +} - return HCF_SUCCESS; +HcfResult GetAlgNameByBits(int32_t keyLen, char **algName) +{ + if (algName == NULL) { + LOGE("Invalid algName"); + return HCF_INVALID_PARAMS; + } + for (uint32_t i = 0; i < sizeof(ALG_NAME_TYPE_MAP) / sizeof(ALG_NAME_TYPE_MAP[0]); i++) { + if (ALG_NAME_TYPE_MAP[i].bits == keyLen) { + size_t srcAlgNameLen = HcfStrlen(ALG_NAME_TYPE_MAP[i].algName); + if (!srcAlgNameLen) { + LOGE("algName is enpty!"); + return HCF_ERR_MALLOC; + } + *algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0); + if (*algName == NULL) { + LOGE("algName malloc failed."); + return HCF_ERR_MALLOC; + } + if (memcpy_s(*algName, srcAlgNameLen, ALG_NAME_TYPE_MAP[i].algName, srcAlgNameLen) != EOK) { + LOGE("memcpy algName failed."); + HcfFree(*algName); + return HCF_ERR_MALLOC; + } + return HCF_SUCCESS; + } + } + LOGE("invalid key size:%d", keyLen); + return HCF_INVALID_PARAMS; +} + +HcfResult GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId) +{ + if (returnCurveId == NULL) { + LOGE("Invalid algName"); + return HCF_INVALID_PARAMS; + } + for (uint32_t i = 0; i < sizeof(NID_TYPE_MAP) / sizeof(NID_TYPE_MAP[0]); i++) { + if (NID_TYPE_MAP[i].bits == keyLen) { + *returnCurveId = NID_TYPE_MAP[i].nid; + return HCF_SUCCESS; + } + } + LOGE("invalid key size:%d", keyLen); + return HCF_INVALID_PARAMS; } HcfResult GetOpensslDigestAlg(uint32_t alg, EVP_MD **digestAlg) @@ -140,7 +257,11 @@ HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString) LOGE("Invalid digest num is %u.", md); return HCF_INVALID_PARAMS; } - size_t mdLen = strlen(tmp); + size_t mdLen = HcfStrlen(tmp); + if (!mdLen) { + LOGE("mdLen is enpty!"); + return HCF_ERR_MALLOC; + } char *mdStr = (char *)HcfMalloc(mdLen + 1, 0); if (mdStr == NULL) { LOGE("Failed to allocate md name memory"); @@ -157,7 +278,11 @@ HcfResult GetRsaSpecStringMGF(char **returnString) LOGE("return string is null"); return HCF_INVALID_PARAMS; } - uint32_t mgf1Len = strlen(HCF_OPENSSL_MGF1); + size_t mgf1Len = HcfStrlen(HCF_OPENSSL_MGF1); + if (!mgf1Len) { + LOGE("mgf1Len is enpty!"); + return HCF_ERR_MALLOC; + } char *mgf1Str = (char *)HcfMalloc(mgf1Len + 1, 0); if (mgf1Str == NULL) { LOGE("Failed to allocate mgf1 name memory"); @@ -168,6 +293,31 @@ HcfResult GetRsaSpecStringMGF(char **returnString) return HCF_SUCCESS; } +HcfResult GetSm2SpecStringSm3(char **returnString) +{ + if (returnString == NULL) { + LOGE("return string is null"); + return HCF_INVALID_PARAMS; + } + size_t sm2Len = HcfStrlen(HCF_OPENSSL_DIGEST_SM3_STR); + if (!sm2Len) { + LOGE("sm2Len is enpty!"); + return HCF_ERR_MALLOC; + } + char *sm2Str = (char *)HcfMalloc(sm2Len + 1, 0); + if (sm2Str == NULL) { + LOGE("Failed to allocate sm2 name memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(sm2Str, sm2Len, HCF_OPENSSL_DIGEST_SM3_STR, sm2Len) != EOK) { + LOGE("memcpy sm2Str failed."); + HcfFree(sm2Str); + return HCF_ERR_MALLOC; + } + *returnString = sm2Str; + return HCF_SUCCESS; +} + void HcfPrintOpensslError(void) { char szErr[LOG_PRINT_MAX_LEN] = {0}; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c index 701eec3..2e3fa7f 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c @@ -275,6 +275,30 @@ static void EngineDesGeneratorDestroy(HcfObjectBase *self) HcfFree(impl); } +static HcfResult GetDesCipherSpecString(HcfCipherGeneratorSpi *self, CipherSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult GetDesCipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob *returnUint8Array) +{ + (void)self; + (void)item; + (void)returnUint8Array; + return HCF_NOT_SUPPORT; +} + +static HcfResult SetDesCipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator) { if ((attr == NULL) || (generator == NULL)) { @@ -291,6 +315,9 @@ HcfResult HcfCipherDesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi returnImpl->base.init = EngineCipherInit; returnImpl->base.update = EngineUpdate; returnImpl->base.doFinal = EngineDoFinal; + returnImpl->base.getCipherSpecString = GetDesCipherSpecString; + returnImpl->base.getCipherSpecUint8Array = GetDesCipherSpecUint8Array; + returnImpl->base.setCipherSpecUint8Array = SetDesCipherSpecUint8Array; returnImpl->base.base.destroy = EngineDesGeneratorDestroy; returnImpl->base.base.getClass = GetDesGeneratorClass; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index 8d27dfc..d98eca0 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -766,6 +766,30 @@ static void EngineAesGeneratorDestroy(HcfObjectBase *self) HcfFree(impl); } +static HcfResult GetAesCipherSpecString(HcfCipherGeneratorSpi *self, CipherSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult GetAesCipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob *returnUint8Array) +{ + (void)self; + (void)item; + (void)returnUint8Array; + return HCF_NOT_SUPPORT; +} + +static HcfResult SetAesCipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator) { if ((attr == NULL) || (generator == NULL)) { @@ -782,6 +806,9 @@ HcfResult HcfCipherAesGeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi returnImpl->base.init = EngineCipherInit; returnImpl->base.update = EngineUpdate; returnImpl->base.doFinal = EngineDoFinal; + returnImpl->base.getCipherSpecString = GetAesCipherSpecString; + returnImpl->base.getCipherSpecUint8Array = GetAesCipherSpecUint8Array; + returnImpl->base.setCipherSpecUint8Array = SetAesCipherSpecUint8Array; returnImpl->base.base.destroy = EngineAesGeneratorDestroy; returnImpl->base.base.getClass = GetAesGeneratorClass; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_openssl.c index 2310932..8ffb21a 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_openssl.c @@ -82,6 +82,40 @@ static HcfResult InitSm2Key(HcfCipherSm2GeneratorSpiImpl *impl, HcfKey *key, enu return HCF_SUCCESS; } +static HcfResult GetSm2CipherSpecString(HcfCipherGeneratorSpi *self, CipherSpecItem item, char **returnString) +{ + if (self == NULL || returnString == NULL) { + LOGE("Param is invalid."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, EngineGetClass())) { + LOGE("Class not match"); + return HCF_INVALID_PARAMS; + } + if (item != SM2_MD_NAME_STR) { + LOGE("Invalid input cipher spec"); + return HCF_INVALID_PARAMS; + } + // only support sm3 + return GetSm2SpecStringSm3(returnString); +} + +static HcfResult GetSm2CipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob *returnUint8Array) +{ + (void)self; + (void)item; + (void)returnUint8Array; + return HCF_NOT_SUPPORT; +} + +static HcfResult SetSm2CipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + static HcfResult EngineInit(HcfCipherGeneratorSpi *self, enum HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) { @@ -256,6 +290,9 @@ HcfResult HcfCipherSm2CipherSpiCreate(CipherAttr *params, HcfCipherGeneratorSpi returnImpl->super.init = EngineInit; returnImpl->super.update = EngineUpdate; returnImpl->super.doFinal = EngineDoFinal; + returnImpl->super.getCipherSpecString = GetSm2CipherSpecString; + returnImpl->super.getCipherSpecUint8Array = GetSm2CipherSpecUint8Array; + returnImpl->super.setCipherSpecUint8Array = SetSm2CipherSpecUint8Array; returnImpl->super.base.destroy = EngineDestroySpiImpl; returnImpl->super.base.getClass = EngineGetClass; returnImpl->initFlag = UNINITIALIZED; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c index b9a9f58..b24218c 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c @@ -362,6 +362,30 @@ static void EngineSm4GeneratorDestroy(HcfObjectBase *self) HcfFree(impl); } +static HcfResult GetSm4CipherSpecString(HcfCipherGeneratorSpi *self, CipherSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult GetSm4CipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob *returnUint8Array) +{ + (void)self; + (void)item; + (void)returnUint8Array; + return HCF_NOT_SUPPORT; +} + +static HcfResult SetSm4CipherSpecUint8Array(HcfCipherGeneratorSpi *self, CipherSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult HcfCipherSm4GeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi **generator) { if (attr == NULL || generator == NULL) { @@ -378,6 +402,9 @@ HcfResult HcfCipherSm4GeneratorSpiCreate(CipherAttr *attr, HcfCipherGeneratorSpi returnImpl->base.init = EngineCipherInit; returnImpl->base.update = EngineUpdate; returnImpl->base.doFinal = EngineDoFinal; + returnImpl->base.getCipherSpecString = GetSm4CipherSpecString; + returnImpl->base.getCipherSpecUint8Array = GetSm4CipherSpecUint8Array; + returnImpl->base.setCipherSpecUint8Array = SetSm4CipherSpecUint8Array; returnImpl->base.base.destroy = EngineSm4GeneratorDestroy; returnImpl->base.base.getClass = GetSm4GeneratorClass; diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c index 8532c1b..cc044de 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c @@ -528,6 +528,14 @@ HcfResult EngineGetSignDsaSpecString(HcfSignSpi *self, SignSpecItem item, char * return HCF_NOT_SUPPORT; } +static HcfResult EngineSetSignDsaSpecUint8Array(HcfSignSpi *self, SignSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult EngineGetVerifyDsaSpecString(HcfVerifySpi *self, SignSpecItem item, char **returnString) { (void)self; @@ -536,6 +544,14 @@ HcfResult EngineGetVerifyDsaSpecString(HcfVerifySpi *self, SignSpecItem item, ch return HCF_NOT_SUPPORT; } +static HcfResult EngineSetVerifyDsaSpecUint8Array(HcfVerifySpi *self, SignSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult HcfSignSpiDsaCreate(HcfSignatureParams *params, HcfSignSpi **returnObj) { if ((params == NULL) || (returnObj == NULL)) { @@ -576,6 +592,7 @@ HcfResult HcfSignSpiDsaCreate(HcfSignatureParams *params, HcfSignSpi **returnObj impl->base.engineSetSignSpecInt = EngineSetSignDsaSpecInt; impl->base.engineGetSignSpecInt = EngineGetSignDsaSpecInt; impl->base.engineGetSignSpecString = EngineGetSignDsaSpecString; + impl->base.engineSetSignSpecUint8Array = EngineSetSignDsaSpecUint8Array; impl->status = UNINITIALIZED; impl->digestAlg = digestAlg; *returnObj = (HcfSignSpi *)impl; @@ -620,6 +637,7 @@ HcfResult HcfVerifySpiDsaCreate(HcfSignatureParams *params, HcfVerifySpi **retur impl->base.engineSetVerifySpecInt = EngineSetVerifyDsaSpecInt; impl->base.engineGetVerifySpecInt = EngineGetVerifyDsaSpecInt; impl->base.engineGetVerifySpecString = EngineGetVerifyDsaSpecString; + impl->base.engineSetVerifySpecUint8Array = EngineSetVerifyDsaSpecUint8Array; impl->digestAlg = digestAlg; impl->status = UNINITIALIZED; 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 98eae1a..ebdd272 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c @@ -61,6 +61,18 @@ static bool IsDigestAlgValid(uint32_t alg) } } +static bool IsBrainPoolDigestAlgValid(uint32_t alg) +{ + if ((alg == HCF_OPENSSL_DIGEST_SHA1) || (alg == HCF_OPENSSL_DIGEST_SHA224) || + (alg == HCF_OPENSSL_DIGEST_SHA256) || (alg == HCF_OPENSSL_DIGEST_SHA384) || + (alg == HCF_OPENSSL_DIGEST_SHA512) || (alg == HCF_OPENSSL_DIGEST_MD5)) { + return true; + } else { + LOGE("Invalid digest num is %u.", alg); + return false; + } +} + // export interfaces static const char *GetEcdsaSignClass(void) { @@ -312,14 +324,86 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign return true; } +HcfResult EngineSetSignEcdsaSpecInt(HcfSignSpi *self, SignSpecItem item, int32_t saltLen) +{ + (void)self; + (void)item; + (void)saltLen; + return HCF_NOT_SUPPORT; +} + +HcfResult EngineSetVerifyEcdsaSpecInt(HcfVerifySpi *self, SignSpecItem item, int32_t saltLen) +{ + (void)self; + (void)item; + (void)saltLen; + return HCF_NOT_SUPPORT; +} + +HcfResult EngineGetSignEcdsaSpecInt(HcfSignSpi *self, SignSpecItem item, int32_t *returnInt) +{ + (void)self; + (void)item; + (void)returnInt; + return HCF_NOT_SUPPORT; +} + +HcfResult EngineGetVerifyEcdsaSpecInt(HcfVerifySpi *self, SignSpecItem item, int32_t *returnInt) +{ + (void)self; + (void)item; + (void)returnInt; + return HCF_NOT_SUPPORT; +} + +HcfResult EngineGetSignEcdsaSpecString(HcfSignSpi *self, SignSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetSignEcdsaSpecUint8Array(HcfSignSpi *self, SignSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + +HcfResult EngineGetVerifyEcdsaSpecString(HcfVerifySpi *self, SignSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetVerifyEcdsaSpecUint8Array(HcfVerifySpi *self, SignSpecItem item, HcfBlob blob) +{ + (void)self; + (void)item; + (void)blob; + return HCF_NOT_SUPPORT; +} + HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnObj) { if ((params == NULL) || (returnObj == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - if (!IsDigestAlgValid(params->md)) { - return HCF_INVALID_PARAMS; + if (params->algo == HCF_ALG_ECC_BRAINPOOL) { + if (!IsBrainPoolDigestAlgValid(params->md)) { + LOGE("Invalid md."); + return HCF_INVALID_PARAMS; + } + } else { + if (!IsDigestAlgValid(params->md)) { + LOGE("Invalid md."); + return HCF_INVALID_PARAMS; + } } EVP_MD *opensslAlg = NULL; int32_t ret = GetOpensslDigestAlg(params->md, &opensslAlg); @@ -339,6 +423,10 @@ HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnO returnImpl->base.engineInit = EngineSignInit; returnImpl->base.engineUpdate = EngineSignUpdate; returnImpl->base.engineSign = EngineSignDoFinal; + returnImpl->base.engineSetSignSpecInt = EngineSetSignEcdsaSpecInt; + returnImpl->base.engineGetSignSpecInt = EngineGetSignEcdsaSpecInt; + returnImpl->base.engineGetSignSpecString = EngineGetSignEcdsaSpecString; + returnImpl->base.engineSetSignSpecUint8Array = EngineSetSignEcdsaSpecUint8Array; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; returnImpl->ctx = Openssl_EVP_MD_CTX_new(); @@ -358,8 +446,14 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - if (!IsDigestAlgValid(params->md)) { - return HCF_INVALID_PARAMS; + if (params->algo == HCF_ALG_ECC_BRAINPOOL) { + if (!IsBrainPoolDigestAlgValid(params->md)) { + return HCF_INVALID_PARAMS; + } + } else { + if (!IsDigestAlgValid(params->md)) { + return HCF_INVALID_PARAMS; + } } EVP_MD *opensslAlg = NULL; int32_t ret = GetOpensslDigestAlg(params->md, &opensslAlg); @@ -379,6 +473,10 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret returnImpl->base.engineInit = EngineVerifyInit; returnImpl->base.engineUpdate = EngineVerifyUpdate; returnImpl->base.engineVerify = EngineVerifyDoFinal; + returnImpl->base.engineSetVerifySpecInt = EngineSetVerifyEcdsaSpecInt; + returnImpl->base.engineGetVerifySpecInt = EngineGetVerifyEcdsaSpecInt; + returnImpl->base.engineGetVerifySpecString = EngineGetVerifyEcdsaSpecString; + returnImpl->base.engineSetVerifySpecUint8Array = EngineSetVerifyEcdsaSpecUint8Array; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; returnImpl->ctx = Openssl_EVP_MD_CTX_new(); 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 56bf9d0..6cf74c0 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 @@ -539,6 +539,14 @@ static HcfResult EngineGetSignSpecInt(HcfSignSpi *self, SignSpecItem item, int32 } } +static HcfResult EngineSetSignSpecUint8Array(HcfSignSpi *self, SignSpecItem item, HcfBlob pSource) +{ + (void)self; + (void)item; + (void)pSource; + return HCF_NOT_SUPPORT; +} + static HcfResult EngineGetSignSpecString(HcfSignSpi *self, SignSpecItem item, char **returnString) { if (self == NULL || returnString == NULL) { @@ -649,6 +657,14 @@ static HcfResult EngineGetVerifySpecInt(HcfVerifySpi *self, SignSpecItem item, i } } +static HcfResult EngineSetVerifySpecUint8Array(HcfVerifySpi *self, SignSpecItem item, HcfBlob pSource) +{ + (void)self; + (void)item; + (void)pSource; + return HCF_NOT_SUPPORT; +} + static HcfResult EngineGetVerifySpecString(HcfVerifySpi *self, SignSpecItem item, char **returnString) { if (self == NULL || returnString == NULL) { @@ -706,7 +722,7 @@ HcfResult HcfSignSpiRsaCreate(HcfSignatureParams *params, HcfSignSpi **returnObj returnImpl->base.engineSetSignSpecInt = EngineSetSignSpecInt; returnImpl->base.engineGetSignSpecInt = EngineGetSignSpecInt; returnImpl->base.engineGetSignSpecString = EngineGetSignSpecString; - + returnImpl->base.engineSetSignSpecUint8Array = EngineSetSignSpecUint8Array; returnImpl->md = params->md; returnImpl->padding = params->padding; returnImpl->mgf1md = params->mgf1md; @@ -740,7 +756,7 @@ HcfResult HcfVerifySpiRsaCreate(HcfSignatureParams *params, HcfVerifySpi **retur returnImpl->base.engineSetVerifySpecInt = EngineSetVerifySpecInt; returnImpl->base.engineGetVerifySpecInt = EngineGetVerifySpecInt; returnImpl->base.engineGetVerifySpecString = EngineGetVerifySpecString; - + returnImpl->base.engineSetVerifySpecUint8Array = EngineSetVerifySpecUint8Array; returnImpl->md = params->md; returnImpl->padding = params->padding; returnImpl->mgf1md = params->mgf1md; diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c index 2254118..bc9bd88 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c @@ -18,6 +18,8 @@ #include #include +#include "securec.h" + #include "algorithm_parameter.h" #include "openssl_adapter.h" #include "openssl_class.h" @@ -32,9 +34,11 @@ typedef struct { HcfSignSpi base; + HcfBlob userId; + const EVP_MD *digestAlg; - EVP_MD_CTX *ctx; + EVP_MD_CTX *mdCtx; CryptoStatus status; } HcfSignSpiSm2OpensslImpl; @@ -42,9 +46,11 @@ typedef struct { typedef struct { HcfVerifySpi base; + HcfBlob userId; + const EVP_MD *digestAlg; - EVP_MD_CTX *ctx; + EVP_MD_CTX *mdCtx; CryptoStatus status; } HcfVerifySpiSm2OpensslImpl; @@ -77,10 +83,12 @@ static void DestroySm2Sign(HcfObjectBase *self) } HcfSignSpiSm2OpensslImpl *impl = (HcfSignSpiSm2OpensslImpl *)self; impl->digestAlg = NULL; - if (impl->ctx != NULL) { - Openssl_EVP_MD_CTX_free(impl->ctx); - impl->ctx = NULL; + if (impl->mdCtx != NULL) { + Openssl_EVP_MD_CTX_free(impl->mdCtx); + impl->mdCtx = NULL; } + HcfFree(impl->userId.data); + impl->userId.data = NULL; HcfFree(impl); } @@ -91,14 +99,56 @@ static void DestroySm2Verify(HcfObjectBase *self) } HcfVerifySpiSm2OpensslImpl *impl = (HcfVerifySpiSm2OpensslImpl *)self; impl->digestAlg = NULL; - if (impl->ctx != NULL) { - Openssl_EVP_MD_CTX_free(impl->ctx); - impl->ctx = NULL; + if (impl->mdCtx != NULL) { + Openssl_EVP_MD_CTX_free(impl->mdCtx); + impl->mdCtx = NULL; } + HcfFree(impl->userId.data); + impl->userId.data = NULL; HcfFree(impl); } +static HcfResult SetUserIdFromBlob(HcfBlob userId, EVP_MD_CTX *mdCtx) +{ + EVP_PKEY_CTX *pKeyCtx = Openssl_EVP_MD_CTX_get_pkey_ctx(mdCtx); + if (pKeyCtx == NULL) { + LOGE("get pKey ctx fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + // If userId is NULL or len is 0, the userId will be cleared. + if (userId.data == NULL || userId.len == 0) { + if (Openssl_EVP_PKEY_CTX_set1_id(pKeyCtx, NULL, 0) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl Set userId fail"); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_EVP_MD_CTX_set_pkey_ctx(mdCtx, pKeyCtx); + return HCF_SUCCESS; + } + // deep copy from userId + uint8_t *opensslUserId = (uint8_t *)HcfMalloc(userId.len, 0); + if (opensslUserId == NULL) { + LOGE("Failed to allocate openssl userId data memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(opensslUserId, userId.len, userId.data, userId.len) != EOK) { + LOGE("memcpy opensslUserId failed."); + HcfFree(opensslUserId); + return HCF_ERR_MALLOC; + } + if (Openssl_EVP_PKEY_CTX_set1_id(pKeyCtx, (const void*)opensslUserId, + userId.len) != HCF_OPENSSL_SUCCESS) { + LOGE("Set sm2 user id fail."); + HcfFree(opensslUserId); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_EVP_MD_CTX_set_pkey_ctx(mdCtx, pKeyCtx); + HcfFree(opensslUserId); + return HCF_SUCCESS; +} -static HcfResult SetSM2Id(EVP_MD_CTX *mdCtx, EVP_PKEY *pKey, char *userId) +static HcfResult SetSM2Id(EVP_MD_CTX *mdCtx, EVP_PKEY *pKey, HcfBlob userId) { EVP_PKEY_CTX *pKeyCtx = Openssl_EVP_PKEY_CTX_new(pKey, NULL); if (pKeyCtx == NULL) { @@ -106,7 +156,8 @@ static HcfResult SetSM2Id(EVP_MD_CTX *mdCtx, EVP_PKEY *pKey, char *userId) HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (Openssl_EVP_PKEY_CTX_set1_id(pKeyCtx, (const void*)userId, strlen(userId)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_CTX_set1_id(pKeyCtx, (const void*)userId.data, + userId.len) != HCF_OPENSSL_SUCCESS) { LOGE("Set sm2 user id fail"); HcfPrintOpensslError(); Openssl_EVP_PKEY_CTX_free(pKeyCtx); @@ -150,11 +201,11 @@ static HcfResult EngineSignInit(HcfSignSpi *self, HcfParamsSpec *params, HcfPriK Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - if (SetSM2Id(impl->ctx, pKey, SM2_DEFAULT_USERID) != HCF_SUCCESS) { + if (SetSM2Id(impl->mdCtx, pKey, impl->userId) != HCF_SUCCESS) { Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - if (Openssl_EVP_DigestSignInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignInit(impl->mdCtx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; @@ -178,7 +229,7 @@ static HcfResult EngineSignUpdate(HcfSignSpi *self, HcfBlob *data) LOGE("Sign object has not been initialized."); return HCF_INVALID_PARAMS; } - if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->mdCtx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -198,7 +249,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret HcfSignSpiSm2OpensslImpl *impl = (HcfSignSpiSm2OpensslImpl *)self; if (IsBlobValid(data)) { - if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->mdCtx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -209,7 +260,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_INVALID_PARAMS; } size_t maxLen; - if (Openssl_EVP_DigestSignFinal(impl->ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->mdCtx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -219,7 +270,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_ERR_MALLOC; } size_t actualLen = maxLen; - if (Openssl_EVP_DigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->mdCtx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; @@ -269,11 +320,11 @@ static HcfResult EngineVerifyInit(HcfVerifySpi *self, HcfParamsSpec *params, Hcf Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - if (SetSM2Id(impl->ctx, pKey, SM2_DEFAULT_USERID) != HCF_SUCCESS) { + if (SetSM2Id(impl->mdCtx, pKey, impl->userId) != HCF_SUCCESS) { Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - if (Openssl_EVP_DigestVerifyInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyInit(impl->mdCtx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; @@ -298,7 +349,7 @@ static HcfResult EngineVerifyUpdate(HcfVerifySpi *self, HcfBlob *data) LOGE("Verify object has not been initialized."); return HCF_INVALID_PARAMS; } - if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->mdCtx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -318,7 +369,7 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign HcfVerifySpiSm2OpensslImpl *impl = (HcfVerifySpiSm2OpensslImpl *)self; if (IsBlobValid(data)) { - if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->mdCtx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } @@ -328,20 +379,195 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign LOGE("The message has not been transferred."); return false; } - if (Openssl_EVP_DigestVerifyFinal(impl->ctx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyFinal(impl->mdCtx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } return true; } -HcfResult HcfSignSpiSm2Create(HcfSignatureParams *params, HcfSignSpi **returnObj) +static HcfResult EngineGetSignSpecString(HcfSignSpi *self, SignSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetSignSpecUint8Array(HcfSignSpi *self, SignSpecItem item, HcfBlob userId) +{ + if (self == NULL) { + LOGE("Invalid input parameter"); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_SM2_SIGN_CLASS)) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + if (item != SM2_USER_ID_UINT8ARR) { + LOGE("Invalid input spec"); + return HCF_INVALID_PARAMS; + } + HcfSignSpiSm2OpensslImpl *impl = (HcfSignSpiSm2OpensslImpl *)self; + // if it has userId from previous set, it should be free at first; + if (impl->userId.data != NULL) { + HcfFree(impl->userId.data); + impl->userId.data = NULL; + } + // If userId is NULL or len is 0, the userId will be cleared. + if (userId.data == NULL || userId.len == 0) { + impl->userId.data = NULL; + impl->userId.len = 0; + } else { + // deep copy two userId, one for impl struct and one for openssl. + impl->userId.data = (uint8_t *)HcfMalloc(userId.len, 0); + if (impl->userId.data == NULL) { + LOGE("Failed to allocate userId data memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(impl->userId.data, userId.len, userId.data, userId.len) != EOK) { + LOGE("memcpy userId failed."); + HcfFree(impl->userId.data); + return HCF_ERR_MALLOC; + } + impl->userId.len = userId.len; + } + // if uninitliszed, userId should only be stored in the struct. + // if initliszed, userId should have another copy and set the copy to the evp ctx. + if (impl->status == INITIALIZED) { + HcfResult ret = SetUserIdFromBlob(impl->userId, impl->mdCtx); + if (ret != HCF_SUCCESS) { + LOGE("Set userId fail"); + HcfFree(impl->userId.data); + impl->userId.data = NULL; + return ret; + } + } + return HCF_SUCCESS; +} + +static HcfResult EngineGetSignSpecInt(HcfSignSpi *self, SignSpecItem item, int32_t *returnInt) +{ + (void)self; + (void)item; + (void)returnInt; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetSignSpecInt(HcfSignSpi *self, SignSpecItem item, int32_t saltLen) +{ + (void)self; + (void)item; + (void)saltLen; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineGetVerifySpecString(HcfVerifySpi *self, SignSpecItem item, char **returnString) +{ + (void)self; + (void)item; + (void)returnString; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetVerifySpecUint8Array(HcfVerifySpi *self, SignSpecItem item, HcfBlob userId) +{ + if (self == NULL) { + LOGE("Invalid input parameter"); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, OPENSSL_SM2_VERIFY_CLASS)) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + if (item != SM2_USER_ID_UINT8ARR) { + LOGE("Invalid input spec"); + return HCF_INVALID_PARAMS; + } + HcfVerifySpiSm2OpensslImpl *impl = (HcfVerifySpiSm2OpensslImpl *)self; + // if it has userId from previous set, it should be free at first; + if (impl->userId.data != NULL) { + HcfFree(impl->userId.data); + impl->userId.data = NULL; + } + // If userId is NULL or len is 0, the userId will be cleared. + if (userId.data == NULL || userId.len == 0) { + impl->userId.data = NULL; + impl->userId.len = 0; + } else { + // deep copy two userId, one for impl struct and one for openssl. + impl->userId.data = (uint8_t *)HcfMalloc(userId.len, 0); + if (impl->userId.data == NULL) { + LOGE("Failed to allocate userId data memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(impl->userId.data, userId.len, userId.data, userId.len) != EOK) { + LOGE("memcpy userId failed."); + HcfFree(impl->userId.data); + return HCF_ERR_MALLOC; + } + impl->userId.len = userId.len; + } + // if uninitliszed, userId should only be stored in the struct. + // if initliszed, userId should have another copy and set the copy to the evp ctx. + if (impl->status == INITIALIZED) { + HcfResult ret = SetUserIdFromBlob(impl->userId, impl->mdCtx); + if (ret != HCF_SUCCESS) { + LOGE("Set userId fail"); + HcfFree(impl->userId.data); + impl->userId.data = NULL; + return ret; + } + } + return HCF_SUCCESS; +} + +static HcfResult EngineGetVerifySpecInt(HcfVerifySpi *self, SignSpecItem item, int32_t *returnInt) +{ + (void)self; + (void)item; + (void)returnInt; + return HCF_NOT_SUPPORT; +} + +static HcfResult EngineSetVerifySpecInt(HcfVerifySpi *self, SignSpecItem item, int32_t saltLen) +{ + (void)self; + (void)item; + (void)saltLen; + return HCF_NOT_SUPPORT; +} + +static HcfResult CheckSignInputParamsAndDigest(HcfSignatureParams *params, HcfSignSpi **returnObj) +{ + if ((params == NULL) || (returnObj == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsDigestAlgValid(params->md)) { + LOGE("Invalid input md parameter."); + return HCF_INVALID_PARAMS; + } + return HCF_SUCCESS; +} + +static HcfResult CheckVerifyInputParamsAndDigest(HcfSignatureParams *params, HcfVerifySpi **returnObj) { if ((params == NULL) || (returnObj == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!IsDigestAlgValid(params->md)) { + LOGE("Invalid input md parameter."); + return HCF_INVALID_PARAMS; + } + return HCF_SUCCESS; +} + +HcfResult HcfSignSpiSm2Create(HcfSignatureParams *params, HcfSignSpi **returnObj) +{ + if (CheckSignInputParamsAndDigest(params, returnObj) != HCF_SUCCESS) { + LOGE("Check input params and digest failed."); return HCF_INVALID_PARAMS; } EVP_MD *opensslAlg = NULL; @@ -362,11 +588,28 @@ HcfResult HcfSignSpiSm2Create(HcfSignatureParams *params, HcfSignSpi **returnObj returnImpl->base.engineInit = EngineSignInit; returnImpl->base.engineUpdate = EngineSignUpdate; returnImpl->base.engineSign = EngineSignDoFinal; + returnImpl->base.engineGetSignSpecString = EngineGetSignSpecString; + returnImpl->base.engineSetSignSpecUint8Array = EngineSetSignSpecUint8Array; + returnImpl->base.engineGetSignSpecInt = EngineGetSignSpecInt; + returnImpl->base.engineSetSignSpecInt = EngineSetSignSpecInt; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = Openssl_EVP_MD_CTX_new(); - if (returnImpl->ctx == NULL) { - LOGE("Failed to allocate ctx memory!"); + returnImpl->userId.data = (uint8_t *)HcfMalloc(strlen(SM2_DEFAULT_USERID) + 1, 0); + if (returnImpl->userId.data == NULL) { + LOGE("Failed to allocate userId data memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(returnImpl->userId.data, strlen(SM2_DEFAULT_USERID), SM2_DEFAULT_USERID, strlen(SM2_DEFAULT_USERID)) + != EOK) { + LOGE("memcpy userId failed."); + HcfFree(returnImpl->userId.data); + return HCF_ERR_MALLOC; + } + returnImpl->userId.len = strlen(SM2_DEFAULT_USERID); + returnImpl->mdCtx = Openssl_EVP_MD_CTX_new(); + if (returnImpl->mdCtx == NULL) { + LOGE("Failed to allocate mdCtx memory!"); + HcfFree(returnImpl->userId.data); HcfFree(returnImpl); return HCF_ERR_MALLOC; } @@ -377,11 +620,8 @@ HcfResult HcfSignSpiSm2Create(HcfSignatureParams *params, HcfSignSpi **returnObj HcfResult HcfVerifySpiSm2Create(HcfSignatureParams *params, HcfVerifySpi **returnObj) { - if ((params == NULL) || (returnObj == NULL)) { - LOGE("Invalid input parameter."); - return HCF_INVALID_PARAMS; - } - if (!IsDigestAlgValid(params->md)) { + if (CheckVerifyInputParamsAndDigest(params, returnObj) != HCF_SUCCESS) { + LOGE("Check input params and digest failed."); return HCF_INVALID_PARAMS; } EVP_MD *opensslAlg = NULL; @@ -402,11 +642,28 @@ HcfResult HcfVerifySpiSm2Create(HcfSignatureParams *params, HcfVerifySpi **retur returnImpl->base.engineInit = EngineVerifyInit; returnImpl->base.engineUpdate = EngineVerifyUpdate; returnImpl->base.engineVerify = EngineVerifyDoFinal; + returnImpl->base.engineGetVerifySpecString = EngineGetVerifySpecString; + returnImpl->base.engineSetVerifySpecUint8Array = EngineSetVerifySpecUint8Array; + returnImpl->base.engineGetVerifySpecInt = EngineGetVerifySpecInt; + returnImpl->base.engineSetVerifySpecInt = EngineSetVerifySpecInt; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = Openssl_EVP_MD_CTX_new(); - if (returnImpl->ctx == NULL) { - LOGE("Failed to allocate ctx memory!"); + returnImpl->userId.data = (uint8_t *)HcfMalloc(strlen(SM2_DEFAULT_USERID) + 1, 0); + if (returnImpl->userId.data == NULL) { + LOGE("Failed to allocate userId data memory"); + return HCF_ERR_MALLOC; + } + if (memcpy_s(returnImpl->userId.data, strlen(SM2_DEFAULT_USERID), SM2_DEFAULT_USERID, strlen(SM2_DEFAULT_USERID)) + != EOK) { + LOGE("memcpy userId failed."); + HcfFree(returnImpl->userId.data); + return HCF_ERR_MALLOC; + } + returnImpl->userId.len = strlen(SM2_DEFAULT_USERID); + returnImpl->mdCtx = Openssl_EVP_MD_CTX_new(); + if (returnImpl->mdCtx == NULL) { + LOGE("Failed to allocate mdCtx memory!"); + HcfFree(returnImpl->userId.data); HcfFree(returnImpl); return HCF_ERR_MALLOC; } diff --git a/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_common_param_spec_generator_openssl.h b/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_common_param_spec_generator_openssl.h new file mode 100644 index 0000000..8a2808b --- /dev/null +++ b/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_common_param_spec_generator_openssl.h @@ -0,0 +1,32 @@ +/* + * 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 HCF_ECC_COMMON_PARAM_SPEC_GENERATOR_OPENSSL_H +#define HCF_ECC_COMMON_PARAM_SPEC_GENERATOR_OPENSSL_H + +#include "ecc_key_util_spi.h" +#include "params_parser.h" +#include "result.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult HcfECCCommonParamSpecCreate(HcfAsyKeyGenParams *params, HcfEccCommParamsSpecSpi **returnCommonParamSpec); + +#ifdef __cplusplus +} +#endif +#endif 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 4a43a8d..c3eb075 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 @@ -30,12 +30,24 @@ #define OPENSSL_ECC_ALGORITHM "EC" #define OPENSSL_ECC_PUB_KEY_FORMAT "X.509" #define OPENSSL_ECC_PRI_KEY_FORMAT "PKCS#8" +#define OPENSSL_ECC160_BITS 160 +#define OPENSSL_ECC192_BITS 192 #define OPENSSL_ECC224_BITS 224 #define OPENSSL_ECC256_BITS 256 +#define OPENSSL_ECC320_BITS 320 #define OPENSSL_ECC384_BITS 384 +#define OPENSSL_ECC512_BITS 512 #define OPENSSL_ECC521_BITS 521 static const char *g_eccGenerateFieldType = "Fp"; + +typedef struct { + BIGNUM *p; + BIGNUM *b; + BIGNUM *x; + BIGNUM *y; +}HcfBigIntegerParams; + typedef struct { HcfAsyKeyGeneratorSpi base; @@ -159,51 +171,488 @@ static HcfResult CheckEc521CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) return HCF_INVALID_PARAMS; } +static HcfResult CheckBP160r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp160r1CorrectBigP, NID_brainpoolP160r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp160r1CorrectBigB, NID_brainpoolP160r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp160r1CorrectBigGX, NID_brainpoolP160r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp160r1CorrectBigGY, NID_brainpoolP160r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 160r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 160r1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP160t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp160t1CorrectBigP, NID_brainpoolP160t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp160t1CorrectBigB, NID_brainpoolP160t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp160t1CorrectBigGX, NID_brainpoolP160t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp160t1CorrectBigGY, NID_brainpoolP160t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 160t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 160t1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP192r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp192r1CorrectBigP, NID_brainpoolP192r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp192r1CorrectBigB, NID_brainpoolP192r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp192r1CorrectBigGX, NID_brainpoolP192r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp192r1CorrectBigGY, NID_brainpoolP192r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 192r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 192r1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP192t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp192t1CorrectBigP, NID_brainpoolP192t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp192t1CorrectBigB, NID_brainpoolP192t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp192t1CorrectBigGX, NID_brainpoolP192t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp192t1CorrectBigGY, NID_brainpoolP192t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 192t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 192t1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP224r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp224r1CorrectBigP, NID_brainpoolP224r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp224r1CorrectBigB, NID_brainpoolP224r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp224r1CorrectBigGX, NID_brainpoolP224r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp224r1CorrectBigGY, NID_brainpoolP224r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 224r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 224r1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP224t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp224t1CorrectBigP, NID_brainpoolP224t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp224t1CorrectBigB, NID_brainpoolP224t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp224t1CorrectBigGX, NID_brainpoolP224t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp224t1CorrectBigGY, NID_brainpoolP224t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 224t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 224t1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP256r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp256r1CorrectBigP, NID_brainpoolP256r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp256r1CorrectBigB, NID_brainpoolP256r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp256r1CorrectBigGX, NID_brainpoolP256r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp256r1CorrectBigGY, NID_brainpoolP256r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 256r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("BP 256r1 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP256t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp256t1CorrectBigP, NID_brainpoolP256t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp256t1CorrectBigB, NID_brainpoolP256t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp256t1CorrectBigGX, NID_brainpoolP256t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp256t1CorrectBigGY, NID_brainpoolP256t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 256t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP320r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp320r1CorrectBigP, NID_brainpoolP320r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp320r1CorrectBigB, NID_brainpoolP320r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp320r1CorrectBigGX, NID_brainpoolP320r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp320r1CorrectBigGY, NID_brainpoolP320r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 320r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP320t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp320t1CorrectBigP, NID_brainpoolP320t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp320t1CorrectBigB, NID_brainpoolP320t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp320t1CorrectBigGX, NID_brainpoolP320t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp320t1CorrectBigGY, NID_brainpoolP320t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 320t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP384r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp384r1CorrectBigP, NID_brainpoolP384r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp384r1CorrectBigB, NID_brainpoolP384r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp384r1CorrectBigGX, NID_brainpoolP384r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp384r1CorrectBigGY, NID_brainpoolP384r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 384r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP384t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp384t1CorrectBigP, NID_brainpoolP384t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp384t1CorrectBigB, NID_brainpoolP384t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp384t1CorrectBigGX, NID_brainpoolP384t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp384t1CorrectBigGY, NID_brainpoolP384t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 384t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP512r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp512r1CorrectBigP, NID_brainpoolP512r1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp512r1CorrectBigB, NID_brainpoolP512r1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp512r1CorrectBigGX, NID_brainpoolP512r1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp512r1CorrectBigGY, NID_brainpoolP512r1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 512r1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckBP512t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_bp512t1CorrectBigP, NID_brainpoolP512t1_len, NULL); + bStd = Openssl_BN_bin2bn(g_bp512t1CorrectBigB, NID_brainpoolP512t1_len, NULL); + xStd = Openssl_BN_bin2bn(g_bp512t1CorrectBigGX, NID_brainpoolP512t1_len, NULL); + yStd = Openssl_BN_bin2bn(g_bp512t1CorrectBigGY, NID_brainpoolP512t1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("BP 512t1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CompareOpenssl160BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + if (CheckBP160r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP160r1; + return HCF_SUCCESS; + } else if (CheckBP160t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP160t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl192BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + if (CheckBP192r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP192r1; + return HCF_SUCCESS; + } else if (CheckBP192t1CurveId(bigIntegerParams->p, bigIntegerParams->b, + bigIntegerParams->x, bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP192t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl224BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + HcfResult res = HCF_INVALID_PARAMS; + res = CheckEc224CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, bigIntegerParams->y); + if (res == HCF_SUCCESS) { + *curveId = NID_secp224r1; + return res; + } else if (CheckBP224r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP224r1; + return HCF_SUCCESS; + } else if (CheckBP224t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP224t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl256BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + HcfResult res = HCF_INVALID_PARAMS; + res = CheckEc256CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, bigIntegerParams->y); + if (res == HCF_SUCCESS) { + *curveId = NID_X9_62_prime256v1; + return res; + } else if (CheckBP256r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP256r1; + return HCF_SUCCESS; + } else if (CheckBP256t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP256t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl320BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + if (CheckBP320r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP320r1; + return HCF_SUCCESS; + } else if (CheckBP320t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP320t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl384BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + HcfResult res = HCF_INVALID_PARAMS; + res = CheckBP384r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, bigIntegerParams->y); + if (res == HCF_SUCCESS) { + *curveId = NID_brainpoolP384r1; + return res; + } else if (CheckEc384CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_secp384r1; + return HCF_SUCCESS; + } else if (CheckBP384t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP384t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl512BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + if (CheckBP512r1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP512r1; + return HCF_SUCCESS; + } else if (CheckBP512t1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_brainpoolP512t1; + return HCF_SUCCESS; + } + return HCF_NOT_SUPPORT; +} + +static HcfResult CompareOpenssl521BitsType(const HcfEccCommParamsSpec *ecParams, int32_t *curveId, + HcfBigIntegerParams *bigIntegerParams) +{ + HcfResult res = CheckEc521CurveId(bigIntegerParams->p, bigIntegerParams->b, + bigIntegerParams->x, bigIntegerParams->y); + if (res == HCF_SUCCESS) { + *curveId = NID_secp521r1; + return res; + } + return HCF_NOT_SUPPORT; +} + static HcfResult CheckParamsSpecToGetCurveId(const HcfEccCommParamsSpec *ecParams, int32_t *curveId) { - BIGNUM *p = NULL, *b = NULL, *x = NULL, *y = NULL; + HcfBigIntegerParams bigIntegerParams; + bigIntegerParams.p = NULL; + bigIntegerParams.b = NULL; + bigIntegerParams.x = NULL; + bigIntegerParams.y = NULL; HcfECFieldFp *field = (HcfECFieldFp *)(ecParams->field); - if (BigIntegerToBigNum(&(field->p), &p) != HCF_SUCCESS || - BigIntegerToBigNum(&(ecParams->b), &b) != HCF_SUCCESS || - BigIntegerToBigNum(&(ecParams->g.x), &x) != HCF_SUCCESS || - BigIntegerToBigNum(&(ecParams->g.y), &y) != HCF_SUCCESS) { + if (BigIntegerToBigNum(&(field->p), &(bigIntegerParams.p)) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->b), &(bigIntegerParams.b)) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->g.x), &(bigIntegerParams.x)) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->g.y), &(bigIntegerParams.y)) != HCF_SUCCESS) { LOGE("BigIntegerToBigNum failed."); - FreeCurveBigNum(p, b, x, y); + FreeCurveBigNum(bigIntegerParams.p, bigIntegerParams.b, bigIntegerParams.x, bigIntegerParams.y); return HCF_ERR_CRYPTO_OPERATION; } - int32_t bitLenP = Openssl_BN_num_bits(p); + int32_t bitLenP = (int32_t)Openssl_BN_num_bits(bigIntegerParams.p); HcfResult res = HCF_INVALID_PARAMS; switch (bitLenP) { + case OPENSSL_ECC160_BITS: + res = CompareOpenssl160BitsType(ecParams, curveId, &bigIntegerParams); + break; + case OPENSSL_ECC192_BITS: + res = CompareOpenssl192BitsType(ecParams, curveId, &bigIntegerParams); + break; case OPENSSL_ECC224_BITS: - res = CheckEc224CurveId(p, b, x, y); - if (res == HCF_SUCCESS) { - *curveId = NID_secp224r1; - } + res = CompareOpenssl224BitsType(ecParams, curveId, &bigIntegerParams); break; case OPENSSL_ECC256_BITS: - res = CheckEc256CurveId(p, b, x, y); - if (res == HCF_SUCCESS) { - *curveId = NID_X9_62_prime256v1; - } + res = CompareOpenssl256BitsType(ecParams, curveId, &bigIntegerParams); + break; + case OPENSSL_ECC320_BITS: + res = CompareOpenssl320BitsType(ecParams, curveId, &bigIntegerParams); break; case OPENSSL_ECC384_BITS: - res = CheckEc384CurveId(p, b, x, y); - if (res == HCF_SUCCESS) { - *curveId = NID_secp384r1; - } + res = CompareOpenssl384BitsType(ecParams, curveId, &bigIntegerParams); + break; + case OPENSSL_ECC512_BITS: + res = CompareOpenssl512BitsType(ecParams, curveId, &bigIntegerParams); break; case OPENSSL_ECC521_BITS: - res = CheckEc521CurveId(p, b, x, y); - if (res == HCF_SUCCESS) { - *curveId = NID_secp521r1; - } + res = CompareOpenssl521BitsType(ecParams, curveId, &bigIntegerParams); break; default: - LOGE("Find no bit len"); + LOGE("Find no bit len:%d", bitLenP); break; } - FreeCurveBigNum(p, b, x, y); + FreeCurveBigNum(bigIntegerParams.p, bigIntegerParams.b, bigIntegerParams.x, bigIntegerParams.y); return res; } @@ -322,6 +771,10 @@ static HcfResult GenerateEcGroupWithParamsSpec(const HcfEccCommParamsSpec *ecPar static HcfResult GenerateEcKeyWithParamsSpec(const HcfEccCommParamsSpec *ecParams, EC_KEY **returnKey) { + if (ecParams == NULL || returnKey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } EC_KEY *ecKey = NULL; int32_t curveId = 0; HcfResult res = CheckParamsSpecToGetCurveId(ecParams, &curveId); @@ -383,7 +836,7 @@ static HcfResult InitEcKeyByPubKey(const HcfPoint *pubKey, EC_KEY *ecKey) // only support fp point. // can use EC_POINT_set_affine_coordinates() set x and y by group, deep copy. - int32_t res = Openssl_EC_POINT_set_affine_coordinates_GFp(group, point, pkX, pkY, NULL); + int res = Openssl_EC_POINT_set_affine_coordinates_GFp(group, point, pkX, pkY, NULL); Openssl_BN_free(pkX); Openssl_BN_free(pkY); @@ -409,7 +862,7 @@ static HcfResult InitEcKeyByPriKey(const HcfBigInteger *priKey, EC_KEY *ecKey) LOGE("BigInteger to BigNum failed."); return HCF_ERR_CRYPTO_OPERATION; } - int32_t res = Openssl_EC_KEY_set_private_key(ecKey, sk); + int32_t res = (int32_t)Openssl_EC_KEY_set_private_key(ecKey, sk); if (res != HCF_OPENSSL_SUCCESS) { LOGE("Openssl_EC_KEY_set_private_key failed."); Openssl_BN_free(sk); @@ -443,7 +896,7 @@ static HcfResult SetEcPubKeyFromPriKey(const HcfBigInteger *priKey, EC_KEY *ecKe Openssl_BN_free(sk); return HCF_ERR_CRYPTO_OPERATION; } - int32_t res = Openssl_EC_KEY_set_public_key(ecKey, point); + int32_t res = (int32_t)Openssl_EC_KEY_set_public_key(ecKey, point); if (res != HCF_OPENSSL_SUCCESS) { LOGE("Openssl_EC_KEY_set_public_key failed."); Openssl_EC_POINT_free(point); @@ -556,7 +1009,7 @@ static HcfResult NewEcPriKeyWithPriSpec(const HcfEccPriKeyParamsSpec *ecParams, } static HcfResult NewEcKeyWithKeyPairSpec(const HcfEccKeyPairParamsSpec *ecParams, EC_KEY **returnEcKey, - const bool needPrivate) + bool needPrivate) { EC_KEY *ecKey = NULL; HcfResult res = GenerateEcKeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey); @@ -979,7 +1432,11 @@ static HcfResult GetFieldType(const HcfKey *self, const bool isPrivate, char **r return HCF_INVALID_PARAMS; } - int32_t len = strlen(fieldType); + size_t len = HcfStrlen(fieldType); + if (!len) { + LOGE("fieldType is empty!"); + return HCF_INVALID_PARAMS; + } *returnString = (char *)HcfMalloc(len + 1, 0); if (*returnString == NULL) { LOGE("Alloc returnString memory failed."); @@ -1000,26 +1457,12 @@ static HcfResult GetCurveName(const HcfKey *self, const bool isPriavte, char **r } char *tmp = NULL; - switch (curveId) { - case NID_secp224r1: - tmp = "NID_secp224r1"; - break; - case NID_X9_62_prime256v1: - tmp = "NID_X9_62_prime256v1"; - break; - case NID_secp384r1: - tmp = "NID_secp384r1"; - break; - case NID_secp521r1: - tmp = "NID_secp521r1"; - break; - default: - LOGE("No curve name."); - return HCF_ERR_CRYPTO_OPERATION; - break; + if (GetCurveNameByCurveId(curveId, &tmp) != HCF_SUCCESS) { + LOGE("get vurveName by curveId failed."); + return HCF_INVALID_PARAMS; } - int32_t len = strlen(tmp); + int32_t len = (int32_t)strlen(tmp); *returnString = (char *)HcfMalloc(len + 1, 0); if (*returnString == NULL) { LOGE("Alloc returnString memory failed."); @@ -1046,7 +1489,7 @@ static HcfResult CheckEcKeySelf(const HcfKey *self, bool *isPrivate) } } -static HcfResult GetPkSkBigInteger(const HcfKey *self, const bool isPrivate, +static HcfResult GetPkSkBigInteger(const HcfKey *self, bool isPrivate, const AsyKeySpecItem item, HcfBigInteger *returnBigInteger) { HcfResult res = HCF_INVALID_PARAMS; @@ -1216,7 +1659,11 @@ static HcfResult PackEccPubKey(int32_t curveId, EC_KEY *ecKey, const char *field } char *tmpFieldType = NULL; if (fieldType != NULL) { - int32_t len = strlen(fieldType); + size_t len = HcfStrlen(fieldType); + if (!len) { + LOGE("fieldType is empty!"); + return HCF_INVALID_PARAMS; + } tmpFieldType = (char *)HcfMalloc(len + 1, 0); if (tmpFieldType == NULL) { LOGE("Alloc tmpFieldType memory failed."); @@ -1252,7 +1699,11 @@ static HcfResult PackEccPriKey(int32_t curveId, EC_KEY *ecKey, const char *field } char *tmpFieldType = NULL; if (fieldType != NULL) { - int32_t len = strlen(fieldType); + size_t len = HcfStrlen(fieldType); + if (!len) { + LOGE("fieldType is empty!"); + return HCF_INVALID_PARAMS; + } tmpFieldType = (char *)HcfMalloc(len + 1, 0); if (tmpFieldType == NULL) { LOGE("Alloc tmpFieldType memory failed."); @@ -1544,7 +1995,7 @@ static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, } // curveId == 0 means no curve to match. - int32_t curveId = Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); if (curveId != 0) { impl->curveId = curveId; } @@ -1577,7 +2028,7 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c LOGE("Gen ec pubKey with spec failed."); return res; } - int32_t curveId = Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); if (curveId != 0) { impl->curveId = curveId; } @@ -1610,7 +2061,7 @@ static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c return res; } - int32_t curveId = Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); if (curveId != 0) { impl->curveId = curveId; } diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c new file mode 100644 index 0000000..5807594 --- /dev/null +++ b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c @@ -0,0 +1,259 @@ +/* + * 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 "ecc_common_param_spec_generator_openssl.h" +#include "securec.h" + +#include "ecc_openssl_common.h" +#include "log.h" +#include "memory.h" +#include "openssl_adapter.h" +#include "openssl_class.h" +#include "openssl_common.h" +#include "utils.h" + +static HcfResult GetOrder(const EC_GROUP *group, HcfBigInteger *returnBigInteger) +{ + BIGNUM *order = Openssl_BN_new(); + if (order == NULL) { + LOGE("new BN failed."); + return HCF_ERR_MALLOC; + } + if (Openssl_EC_GROUP_get_order(group, order, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("get order failed."); + Openssl_BN_free(order); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = BigNumToBigInteger(order, returnBigInteger); + Openssl_BN_free(order); + return ret; +} + +static HcfResult GetCofactor(const EC_GROUP *group, int32_t *returnCofactor) +{ + BIGNUM *cofactor = Openssl_BN_new(); + if (cofactor == NULL) { + LOGE("new cofactor failed."); + return HCF_ERR_MALLOC; + } + + if (Openssl_EC_GROUP_get_cofactor(group, cofactor, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("get cofactor failed."); + Openssl_BN_free(cofactor); + return HCF_ERR_CRYPTO_OPERATION; + } + + *returnCofactor = (int32_t)(Openssl_BN_get_word(cofactor)); + if (*returnCofactor == 0) { + LOGE("get word failed."); + Openssl_BN_free(cofactor); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_BN_free(cofactor); + return HCF_SUCCESS; +} + +static HcfResult BuildCommonParamPart(const EC_GROUP *ecGroup, HcfEccCommParamsSpecSpi *returnCommonParamSpec) +{ + EC_POINT *point = Openssl_EC_POINT_new(ecGroup); + if (point == NULL) { + LOGE("new ec point failed."); + return HCF_ERR_MALLOC; + } + if (!Openssl_EC_POINT_copy(point, Openssl_EC_GROUP_get0_generator(ecGroup))) { + LOGE("ec point copy failed."); + Openssl_EC_POINT_free(point); + return HCF_ERR_CRYPTO_OPERATION; + } + BIGNUM *x = Openssl_BN_new(); + if (x == NULL) { + LOGE("new x failed."); + Openssl_EC_POINT_free(point); + return HCF_ERR_MALLOC; + } + BIGNUM *y = Openssl_BN_new(); + if (y == NULL) { + LOGE("new y failed."); + Openssl_BN_free(x); + Openssl_EC_POINT_free(point); + return HCF_ERR_MALLOC; + } + HcfResult ret = HCF_SUCCESS; + if (!Openssl_EC_POINT_get_affine_coordinates_GFp(ecGroup, point, x, y, NULL)) { + LOGE("EC_POINT_get_affine_coordinates_GFp failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + if (BigNumToBigInteger(x, &(returnCommonParamSpec->paramsSpec.g.x)) != HCF_SUCCESS) { + LOGE("new commonParamSpec x failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + if (BigNumToBigInteger(y, &(returnCommonParamSpec->paramsSpec.g.y)) != HCF_SUCCESS) { + LOGE("new commonParamSpec y failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + Openssl_BN_free(x); + Openssl_BN_free(y); + Openssl_EC_POINT_free(point); + return ret; +} + +static HcfResult BuildCommonParamGFp(const EC_GROUP *ecGroup, HcfEccCommParamsSpecSpi *returnCommonParamSpec) +{ + BIGNUM *p = Openssl_BN_new(); + if (p == NULL) { + LOGE("new p failed."); + return HCF_ERR_MALLOC; + } + BIGNUM *a = Openssl_BN_new(); + if (a == NULL) { + LOGE("new a failed."); + Openssl_BN_free(p); + return HCF_ERR_MALLOC; + } + BIGNUM *b = Openssl_BN_new(); + if (b == NULL) { + LOGE("new b failed."); + Openssl_BN_free(p); + Openssl_BN_free(a); + return HCF_ERR_MALLOC; + } + if (!Openssl_EC_GROUP_get_curve_GFp(ecGroup, p, a, b, NULL)) { + LOGE("EC_GROUP_get_curve_GFp failed."); + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + return HCF_ERR_CRYPTO_OPERATION; + } + HcfResult ret = HCF_SUCCESS; + if (BigNumToBigInteger(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { + LOGE("new commonParamSpec a failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + if (BigNumToBigInteger(b, &(returnCommonParamSpec->paramsSpec.b)) != HCF_SUCCESS) { + LOGE("new commonParamSpec b failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + HcfECFieldFp *tmpField = (HcfECFieldFp *)(returnCommonParamSpec->paramsSpec.field); + if (BigNumToBigInteger(p, &(tmpField->p)) != HCF_SUCCESS) { + LOGE("new commonParamSpec p failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + return ret; +} + +static HcfResult BuildCommonParam(const EC_GROUP *ecGroup, HcfEccCommParamsSpecSpi *returnCommonParamSpec) +{ + if (BuildCommonParamPart(ecGroup, returnCommonParamSpec)!= HCF_SUCCESS) { + LOGE("BuildCommonParamPartOne failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + if (BuildCommonParamGFp(ecGroup, returnCommonParamSpec)!= HCF_SUCCESS) { + LOGE("BuildCommonParamGFp failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + if (GetOrder(ecGroup, &(returnCommonParamSpec->paramsSpec.n)) != HCF_SUCCESS) { + LOGE("Failed to get curve order data."); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (GetCofactor(ecGroup, &(returnCommonParamSpec->paramsSpec.h)) != HCF_SUCCESS) { + LOGE("Failed to get curve cofactor data."); + return HCF_ERR_CRYPTO_OPERATION; + } + return HCF_SUCCESS; +} + +static HcfEccCommParamsSpecSpi *BuildEccCommonParamObject() +{ + HcfEccCommParamsSpecSpi *spi = (HcfEccCommParamsSpecSpi*)HcfMalloc(sizeof(HcfEccCommParamsSpecSpi), 0); + if (spi == NULL) { + LOGE("failed to build ecc commonParam object."); + return NULL; + } + spi->paramsSpec.field = (HcfECField *)HcfMalloc(sizeof(HcfECFieldFp), 0); + if (spi->paramsSpec.field == NULL) { + LOGE("field malloc failed."); + HcfFree(spi); + return NULL; + } + char *fieldType = "Fp"; + size_t srcFieldTypeLen = HcfStrlen(fieldType); + if (!srcFieldTypeLen) { + LOGE("fieldType is empty!"); + HcfFree(spi->paramsSpec.field); + HcfFree(spi); + return NULL; + } + spi->paramsSpec.field->fieldType = (char *)HcfMalloc(srcFieldTypeLen + 1, 0); + if (spi->paramsSpec.field->fieldType == NULL) { + LOGE("fieldType malloc failed."); + HcfFree(spi->paramsSpec.field); + HcfFree(spi); + return NULL; + } + + if (memcpy_s(spi->paramsSpec.field->fieldType, srcFieldTypeLen, fieldType, srcFieldTypeLen) != EOK) { + LOGE("memcpy fieldType failed."); + HcfFree(spi->paramsSpec.field->fieldType); + HcfFree(spi->paramsSpec.field); + HcfFree(spi); + return NULL; + } + return spi; +} + +HcfResult HcfECCCommonParamSpecCreate(HcfAsyKeyGenParams *params, HcfEccCommParamsSpecSpi **returnCommonParamSpec) +{ + if ((params == NULL) || (returnCommonParamSpec == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + int32_t curveId = 0; + if (params->bits != 0) { + if (GetOpensslCurveId(params->bits, &curveId) != HCF_SUCCESS) { + LOGE("curveId parameter failed."); + return HCF_INVALID_PARAMS; + } + } + EC_GROUP *ecGroup = Openssl_EC_GROUP_new_by_curve_name(curveId); + if (ecGroup == NULL) { + LOGE("create ecGroup failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + HcfEccCommParamsSpecSpi *object = BuildEccCommonParamObject(); + if (object == NULL) { + LOGE("build ecc common params object failed."); + Openssl_EC_GROUP_free(ecGroup); + return HCF_ERR_MALLOC; + } + object->paramsSpec.base.specType = HCF_COMMON_PARAMS_SPEC; + if (GetAlgNameByBits(params->bits, &(object->paramsSpec.base.algName)) != HCF_SUCCESS) { + LOGE("get algName parameter failed."); + Openssl_EC_GROUP_free(ecGroup); + return HCF_INVALID_PARAMS; + } + if (BuildCommonParam(ecGroup, object)!= HCF_SUCCESS) { + LOGE("create keyPair failed."); + Openssl_EC_GROUP_free(ecGroup); + return HCF_ERR_CRYPTO_OPERATION; + } + *returnCommonParamSpec = object; + Openssl_EC_GROUP_free(ecGroup); + return HCF_SUCCESS; +} diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c index 77f69fa..008fc39 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c @@ -15,17 +15,21 @@ #include "sm2_asy_key_generator_openssl.h" #include "securec.h" -#include "log.h" -#include "memory.h" #include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" +#include "detailed_ecc_key_params.h" +#include "ecc_openssl_common.h" +#include "log.h" +#include "memory.h" #include "utils.h" +#define OPENSSL_SM2_256_BITS 256 #define OPENSSL_SM2_KEY_GENERATOR_CLASS "OPENSSL.SM2.KEY_GENERATOR_CLASS" #define OPENSSL_SM2_ALGORITHM "SM2" #define OPENSSL_SM2_PUB_KEY_FORMAT "X.509" #define OPENSSL_SM2_PRI_KEY_FORMAT "PKCS#8" +static const char *const g_sm2GenerateFieldType = "Fp"; typedef struct { HcfAsyKeyGeneratorSpi base; @@ -54,6 +58,451 @@ static HcfResult NewEcKeyPair(int32_t curveId, EC_KEY **returnEcKey) return HCF_SUCCESS; } +static void FreeCurveBigNum(BIGNUM *pStd, BIGNUM *bStd, BIGNUM *xStd, BIGNUM *yStd) +{ + Openssl_BN_free(pStd); + Openssl_BN_free(bStd); + Openssl_BN_free(xStd); + Openssl_BN_free(yStd); +} + +static HcfResult CheckSm256CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL, *bStd = NULL, *xStd = NULL, *yStd = NULL; + pStd = Openssl_BN_bin2bn(g_sm256CorrectBigP, NID_X9_62_prime256v1_len, NULL); + bStd = Openssl_BN_bin2bn(g_sm256CorrectBigB, NID_X9_62_prime256v1_len, NULL); + xStd = Openssl_BN_bin2bn(g_sm256CorrectBigGX, NID_X9_62_prime256v1_len, NULL); + yStd = Openssl_BN_bin2bn(g_sm256CorrectBigGY, NID_X9_62_prime256v1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGE("EC 256 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_BN_cmp(p, pStd) == 0 && Openssl_BN_cmp(b, bStd) == 0 && + Openssl_BN_cmp(x, xStd) == 0 && Openssl_BN_cmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + LOGE("EC 256 compare fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + +static HcfResult CheckParamsSpecToGetCurveId(const HcfEccCommParamsSpec *ecParams, int32_t *curveId) +{ + BIGNUM *p = NULL, *b = NULL, *x = NULL, *y = NULL; + HcfECFieldFp *field = (HcfECFieldFp *)(ecParams->field); + if (BigIntegerToBigNum(&(field->p), &p) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->b), &b) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->g.x), &x) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->g.y), &y) != HCF_SUCCESS) { + LOGE("BigIntegerToBigNum failed."); + FreeCurveBigNum(p, b, x, y); + return HCF_ERR_CRYPTO_OPERATION; + } + + int32_t bitLenP = (int32_t)Openssl_BN_num_bits(p); + HcfResult ret = HCF_INVALID_PARAMS; + if (bitLenP != OPENSSL_SM2_256_BITS) { + LOGE("Find no bit len"); + FreeCurveBigNum(p, b, x, y); + return ret; + } + ret = CheckSm256CurveId(p, b, x, y); + if (ret == HCF_SUCCESS) { + *curveId = NID_sm2; + } + FreeCurveBigNum(p, b, x, y); + return ret; +} + +static HcfResult NewGroupFromCurveGFp(const HcfEccCommParamsSpec *ecParams, EC_GROUP **ecGroup, BN_CTX *ctx) +{ + HcfResult ret = HCF_SUCCESS; + HcfECFieldFp *field = (HcfECFieldFp *)(ecParams->field); + BIGNUM *p = NULL, *a = NULL, *b = NULL; + EC_GROUP *group = NULL; + do { + if (BigIntegerToBigNum(&(field->p), &p) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->a), &a) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->b), &b) != HCF_SUCCESS) { + LOGE("BigInteger to BigNum failed"); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + group = Openssl_EC_GROUP_new_curve_GFp(p, a, b, ctx); + if (group == NULL) { + LOGE("Alloc group memory failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + } while (0); + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + + if (ret != HCF_SUCCESS) { + Openssl_EC_GROUP_free(group); + return ret; + } + *ecGroup = group; + return ret; +} + +static HcfResult SetSm2PointToGroup(const HcfEccCommParamsSpec *ecParams, EC_GROUP *group, BN_CTX *ctx) +{ + HcfResult ret = HCF_SUCCESS; + BIGNUM *x = NULL, *y = NULL; + BIGNUM *order = NULL; + EC_POINT *generator = NULL; + BIGNUM *cofactor = Openssl_BN_new(); + if (cofactor == NULL) { + LOGE("Alloc cofactor memory failed."); + return HCF_ERR_MALLOC; + } + do { + if (BigIntegerToBigNum(&(ecParams->g.x), &x) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->g.y), &y) != HCF_SUCCESS || + BigIntegerToBigNum(&(ecParams->n), &order) != HCF_SUCCESS || + !Openssl_BN_set_word(cofactor, (uint32_t)ecParams->h)) { + LOGE("BigInteger to BigNum failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + generator = Openssl_EC_POINT_new(group); + if (generator == NULL) { + LOGE("Alloc group memory failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + if (!Openssl_EC_POINT_set_affine_coordinates_GFp(group, generator, x, y, ctx)) { + LOGE("Openssl_EC_POINT_set_affine_coordinates_GFp failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + HcfPrintOpensslError(); + break; + } + + if (!Openssl_EC_GROUP_set_generator(group, generator, order, cofactor)) { + LOGE("Openssl_EC_GROUP_set_generator failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + HcfPrintOpensslError(); + break; + } + } while (0); + Openssl_BN_free(x); + Openssl_BN_free(y); + Openssl_BN_free(order); + Openssl_BN_free(cofactor); + Openssl_EC_POINT_free(generator); + return ret; +} + +static HcfResult GenerateSm2GroupWithParamsSpec(const HcfEccCommParamsSpec *ecParams, EC_GROUP **ecGroup) +{ + if (ecParams == NULL || ecGroup == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_GROUP *group = NULL; + BN_CTX *ctx = Openssl_BN_CTX_new(); + if (ctx == NULL) { + LOGE("Alloc ctx memory failed."); + return HCF_ERR_MALLOC; + } + HcfResult ret = NewGroupFromCurveGFp(ecParams, &group, ctx); + if (ret != HCF_SUCCESS) { + LOGE("New Ec group fail"); + Openssl_BN_CTX_free(ctx); + return ret; + } + ret = SetSm2PointToGroup(ecParams, group, ctx); + if (ret != HCF_SUCCESS) { + Openssl_BN_CTX_free(ctx); + Openssl_EC_GROUP_free(group); + LOGE("Set Ec point fail"); + return ret; + } + *ecGroup = group; + return ret; +} + +static HcfResult GenerateSm2KeyWithParamsSpec(const HcfEccCommParamsSpec *ecParams, EC_KEY **returnKey) +{ + if (ecParams == NULL || returnKey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_KEY *ecKey = NULL; + int32_t curveId = 0; + HcfResult ret = CheckParamsSpecToGetCurveId(ecParams, &curveId); + if (ret == HCF_SUCCESS && curveId != 0) { + ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); + LOGD("generate EC_KEY by curve name"); + if (ecKey == NULL) { + LOGE("new ec key failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } else { + EC_GROUP *group = NULL; + ret = GenerateSm2GroupWithParamsSpec(ecParams, &group); + if (ret != HCF_SUCCESS) { + LOGE("GenerateSm2GroupWithParamsSpec failed."); + return ret; + } + ecKey = Openssl_EC_KEY_new(); + if (ecKey == NULL) { + LOGE("Openssl_EC_KEY_new failed."); + Openssl_EC_GROUP_free(group); + return HCF_ERR_CRYPTO_OPERATION; + } + if (Openssl_EC_KEY_set_group(ecKey, group) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_KEY_set_group failed."); + Openssl_EC_GROUP_free(group); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_EC_GROUP_free(group); + LOGD("generate EC_KEY by group spec parmas"); + } + // all exceptions have been returned above. + *returnKey = ecKey; + return HCF_SUCCESS; +} + +static HcfResult InitEcKeyByPubKey(const HcfPoint *pubKey, EC_KEY *ecKey) +{ + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); + if (group == NULL) { + LOGE("Not find group from ecKey."); + return HCF_ERR_CRYPTO_OPERATION; + } + EC_POINT *point = Openssl_EC_POINT_new(group); + if (point == NULL) { + LOGE("New ec point failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + BIGNUM *pkX = NULL, *pkY = NULL; + if (BigIntegerToBigNum(&(pubKey->x), &pkX) != HCF_SUCCESS || + BigIntegerToBigNum(&(pubKey->y), &pkY) != HCF_SUCCESS) { + LOGE("BigInteger to BigNum failed."); + Openssl_EC_POINT_free(point); + Openssl_BN_free(pkX); + Openssl_BN_free(pkY); + return HCF_ERR_CRYPTO_OPERATION; + } + + // only support fp point. + // can use EC_POINT_set_affine_coordinates() set x and y by group, deep copy. + int32_t ret = (int32_t)Openssl_EC_POINT_set_affine_coordinates_GFp(group, point, pkX, pkY, NULL); + Openssl_BN_free(pkX); + Openssl_BN_free(pkY); + + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_POINT_set_affine_coordinates_GFp failed."); + Openssl_EC_POINT_free(point); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = Openssl_EC_KEY_set_public_key(ecKey, point); + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_KEY_set_public_key failed."); + Openssl_EC_POINT_free(point); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_EC_POINT_free(point); + return HCF_SUCCESS; +} + +static HcfResult InitEcKeyByPriKey(const HcfBigInteger *priKey, EC_KEY *ecKey) +{ + BIGNUM *sk = NULL; + if (BigIntegerToBigNum(priKey, &sk) != HCF_SUCCESS) { + LOGE("BigInteger to BigNum failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + int32_t ret = (int32_t)Openssl_EC_KEY_set_private_key(ecKey, sk); + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_KEY_set_private_key failed."); + Openssl_BN_free(sk); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_BN_free(sk); + return HCF_SUCCESS; +} + +static HcfResult SetEcPubKeyFromPriKey(const HcfBigInteger *priKey, EC_KEY *ecKey) +{ + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); + if (group == NULL) { + LOGE("Not find group from ecKey."); + return HCF_ERR_CRYPTO_OPERATION; + } + BIGNUM *sk = NULL; + if (BigIntegerToBigNum(priKey, &sk) != HCF_SUCCESS) { + LOGE("BigInteger to BigNum failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + HcfResult ret = HCF_SUCCESS; + EC_POINT *point = Openssl_EC_POINT_new(group); + if (point == NULL) { + LOGE("Openssl_EC_POINT_new failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + if (!Openssl_EC_POINT_mul(group, point, sk, NULL, NULL, NULL)) { + LOGE("Openssl_EC_POINT_new or Openssl_EC_POINT_mul failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + if (!Openssl_EC_KEY_set_public_key(ecKey, point)) { + LOGE("Openssl_EC_KEY_set_public_key failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + } + Openssl_EC_POINT_free(point); + Openssl_BN_free(sk); + return ret; +} + +static HcfResult SetEcKey(const HcfPoint *pubKey, const HcfBigInteger *priKey, EC_KEY *ecKey) +{ + HcfResult ret = HCF_SUCCESS; + if (pubKey != NULL) { + ret = InitEcKeyByPubKey(pubKey, ecKey); + if (ret != HCF_SUCCESS) { + LOGE("InitEcKeyByPubKey failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } + if (priKey != NULL) { + ret = InitEcKeyByPriKey(priKey, ecKey); + if (ret != HCF_SUCCESS) { + LOGE("InitEcKeyByPriKey failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + if (pubKey == NULL) { + ret = SetEcPubKeyFromPriKey(priKey, ecKey); + if (ret != HCF_SUCCESS) { + LOGE("SetEcPubKeyFromPriKey failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } + } + return ret; +} + +static HcfResult NewSm2KeyPairWithCommSpec(const HcfEccCommParamsSpec *ecParams, EC_KEY **returnEckey) +{ + if (ecParams == NULL || returnEckey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_KEY *ecKey = NULL; + HcfResult ret = GenerateSm2KeyWithParamsSpec(ecParams, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("generate EC key fails"); + return ret; + } + if (Openssl_EC_KEY_generate_key(ecKey) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_KEY_generate_key failed."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { + LOGE("Check key fail."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + *returnEckey = ecKey; + return ret; +} + +static HcfResult NewSm2PubKeyWithPubSpec(const HcfEccPubKeyParamsSpec *ecParams, EC_KEY **returnEcKey) +{ + if (ecParams == NULL || returnEcKey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_KEY *ecKey = NULL; + HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("generate EC key fails"); + return ret; + } + ret = SetEcKey(&(ecParams->pk), NULL, ecKey); + if (ret != HCF_SUCCESS) { + LOGE("Set pub ecKey failed."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { + LOGE("Check key fail."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + *returnEcKey = ecKey; + return ret; +} + +static HcfResult NewSm2PriKeyWithPriSpec(const HcfEccPriKeyParamsSpec *ecParams, EC_KEY **returnEcKey) +{ + if (ecParams == NULL || returnEcKey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_KEY *ecKey = NULL; + HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("generate EC key fails"); + return ret; + } + ret = SetEcKey(NULL, &(ecParams->sk), ecKey); + if (ret != HCF_SUCCESS) { + LOGE("Set pri ecKey failed."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { + LOGE("Check key fail."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + *returnEcKey = ecKey; + return ret; +} + +static HcfResult NewSm2KeyWithKeyPairSpec(const HcfEccKeyPairParamsSpec *ecParams, EC_KEY **returnEcKey, + bool needPrivate) +{ + if (ecParams == NULL || returnEcKey == NULL) { + LOGE("Invalid input parameters."); + return HCF_INVALID_PARAMS; + } + EC_KEY *ecKey = NULL; + HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("generate EC key fails"); + return ret; + } + if (needPrivate) { + ret = SetEcKey(&(ecParams->pk), &(ecParams->sk), ecKey); + } else { + ret = SetEcKey(&(ecParams->pk), NULL, ecKey); + } + if (ret != HCF_SUCCESS) { + LOGE("SetEcKey failed."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { + LOGE("Check key fail."); + Openssl_EC_KEY_free(ecKey); + return HCF_ERR_CRYPTO_OPERATION; + } + *returnEcKey = ecKey; + return ret; +} + static const char *GetSm2KeyPairGeneratorClass(void) { return OPENSSL_SM2_KEY_GENERATOR_CLASS; @@ -79,7 +528,7 @@ static void DestroySm2KeyPairGenerator(HcfObjectBase *self) if (self == NULL) { return; } - if (!IsClassMatch(self, self->getClass())) { + if (!IsClassMatch(self, GetSm2KeyPairGeneratorClass())) { return; } HcfFree(self); @@ -90,12 +539,14 @@ static void DestroySm2PubKey(HcfObjectBase *self) if (self == NULL) { return; } - if (!IsClassMatch(self, self->getClass())) { + if (!IsClassMatch(self, GetSm2PubKeyClass())) { return; } HcfOpensslSm2PubKey *impl = (HcfOpensslSm2PubKey *)self; Openssl_EC_KEY_free(impl->ecKey); impl->ecKey = NULL; + HcfFree(impl->fieldType); + impl->fieldType = NULL; HcfFree(impl); } @@ -104,12 +555,14 @@ static void DestroySm2PriKey(HcfObjectBase *self) if (self == NULL) { return; } - if (!IsClassMatch(self, self->getClass())) { + if (!IsClassMatch(self, GetSm2PriKeyClass())) { return; } HcfOpensslSm2PriKey *impl = (HcfOpensslSm2PriKey *)self; Openssl_EC_KEY_free(impl->ecKey); impl->ecKey = NULL; + HcfFree(impl->fieldType); + impl->fieldType = NULL; HcfFree(impl); } @@ -118,7 +571,7 @@ static void DestroySm2KeyPair(HcfObjectBase *self) if (self == NULL) { return; } - if (!IsClassMatch(self, self->getClass())) { + if (!IsClassMatch(self, GetSm2KeyPairClass())) { return; } HcfOpensslSm2KeyPair *impl = (HcfOpensslSm2KeyPair *)self; @@ -255,7 +708,7 @@ static void Sm2PriKeyClearMem(HcfPriKey *self) if (self == NULL) { return; } - if (!IsClassMatch((HcfObjectBase *)self, self->base.base.getClass())) { + if (!IsClassMatch((HcfObjectBase *)self, GetSm2PriKeyClass())) { return; } HcfOpensslSm2PriKey *impl = (HcfOpensslSm2PriKey *)self; @@ -263,7 +716,432 @@ static void Sm2PriKeyClearMem(HcfPriKey *self) impl->ecKey = NULL; } -static HcfResult PackSm2PubKey(int32_t curveId, EC_KEY *ecKey, HcfOpensslSm2PubKey **returnObj) +static HcfResult GetCurveGFp(const EC_GROUP *group, const AsyKeySpecItem item, HcfBigInteger *returnBigInteger) +{ + BIGNUM *p = Openssl_BN_new(); + BIGNUM *a = Openssl_BN_new(); + BIGNUM *b = Openssl_BN_new(); + if (p == NULL || a == NULL || b == NULL) { + LOGE("new BN failed."); + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_GROUP_get_curve_GFp(group, p, a, b, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_GROUP_get_curve_GFp failed."); + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = HCF_INVALID_PARAMS; + switch (item) { + case ECC_FP_P_BN: + ret = BigNumToBigInteger(p, returnBigInteger); + break; + case ECC_A_BN: + ret = BigNumToBigInteger(a, returnBigInteger); + break; + case ECC_B_BN: + ret = BigNumToBigInteger(b, returnBigInteger); + break; + default: + LOGE("Invalid ecc key big number spec!"); + break; + } + Openssl_BN_free(p); + Openssl_BN_free(a); + Openssl_BN_free(b); + return ret; +} + +static HcfResult GetGenerator(const EC_GROUP *group, const AsyKeySpecItem item, HcfBigInteger *returnBigInteger) +{ + const EC_POINT *generator = Openssl_EC_GROUP_get0_generator(group); + if (generator == NULL) { + LOGE("Openssl_EC_GROUP_get0_generator failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + + BIGNUM *gX = Openssl_BN_new(); + BIGNUM *gY = Openssl_BN_new(); + if (gX == NULL || gY == NULL) { + LOGE("new BN failed."); + Openssl_BN_free(gX); + Openssl_BN_free(gY); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_POINT_get_affine_coordinates_GFp(group, generator, gX, gY, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_POINT_get_affine_coordinates_GFp failed."); + Openssl_BN_free(gX); + Openssl_BN_free(gY); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = HCF_INVALID_PARAMS; + switch (item) { + case ECC_G_X_BN: + ret = BigNumToBigInteger(gX, returnBigInteger); + break; + case ECC_G_Y_BN: + ret = BigNumToBigInteger(gY, returnBigInteger); + break; + default: + LOGE("Invalid ecc key big number spec!"); + break; + } + Openssl_BN_free(gX); + Openssl_BN_free(gY); + return ret; +} + +static HcfResult GetOrder(const EC_GROUP *group, HcfBigInteger *returnBigInteger) +{ + BIGNUM *order = Openssl_BN_new(); + if (order == NULL) { + LOGE("new BN failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_GROUP_get_order(group, order, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_POINT_get_affine_coordinates_GFp failed."); + Openssl_BN_free(order); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = BigNumToBigInteger(order, returnBigInteger); + Openssl_BN_free(order); + return ret; +} + +static HcfResult GetCofactor(const EC_GROUP *group, int *returnCofactor) +{ + BIGNUM *cofactor = Openssl_BN_new(); + if (cofactor == NULL) { + LOGE("new BN failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_GROUP_get_cofactor(group, cofactor, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_POINT_get_affine_coordinates_GFp failed."); + Openssl_BN_free(cofactor); + return HCF_ERR_CRYPTO_OPERATION; + } + + *returnCofactor = (int)(Openssl_BN_get_word(cofactor)); + // cofactor should not be zero. + if (*returnCofactor == 0) { + LOGE("Openssl_BN_get_word failed."); + Openssl_BN_free(cofactor); + return HCF_ERR_CRYPTO_OPERATION; + } + Openssl_BN_free(cofactor); + return HCF_SUCCESS; +} + +static HcfResult GetFieldSize(const EC_GROUP *group, int32_t *fieldSize) +{ + *fieldSize = Openssl_EC_GROUP_get_degree(group); + if (*fieldSize == 0) { + LOGE("Openssl_EC_GROUP_get_degree failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + return HCF_SUCCESS; +} + +static HcfResult GetPubKeyXOrY(const EC_GROUP *group, const EC_POINT *point, const AsyKeySpecItem item, + HcfBigInteger *returnBigInteger) +{ + BIGNUM *pkX = Openssl_BN_new(); + BIGNUM *pkY = Openssl_BN_new(); + if (pkX == NULL || pkY == NULL) { + LOGE("new BN failed."); + Openssl_BN_free(pkX); + Openssl_BN_free(pkY); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (Openssl_EC_POINT_get_affine_coordinates_GFp(group, point, pkX, pkY, NULL) != HCF_OPENSSL_SUCCESS) { + LOGE("Openssl_EC_POINT_get_affine_coordinates_GFp failed."); + Openssl_BN_free(pkX); + Openssl_BN_free(pkY); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult ret = HCF_INVALID_PARAMS; + switch (item) { + case ECC_PK_X_BN: + ret = BigNumToBigInteger(pkX, returnBigInteger); + break; + case ECC_PK_Y_BN: + ret = BigNumToBigInteger(pkY, returnBigInteger); + break; + default: + LOGE("Invalid ecc key big number spec!"); + break; + } + Openssl_BN_free(pkX); + Openssl_BN_free(pkY); + return ret; +} + +static HcfResult GetFieldType(const HcfKey *self, bool isPrivate, char **returnString) +{ + char *fieldType = NULL; + if (isPrivate) { + fieldType = ((HcfOpensslSm2PriKey *)self)->fieldType; + } else { + fieldType = ((HcfOpensslSm2PubKey *)self)->fieldType; + } + + if (fieldType == NULL) { + LOGE("No fieldType in Sm2PubKey struct."); + return HCF_INVALID_PARAMS; + } + + size_t len = HcfStrlen(fieldType); + if (!len) { + LOGE("fieldType is empty!"); + return HCF_INVALID_PARAMS; + } + *returnString = (char *)HcfMalloc(len + 1, 0); + if (*returnString == NULL) { + LOGE("Alloc returnString memory failed."); + return HCF_ERR_MALLOC; + } + if (memcpy_s(*returnString, len, fieldType, len) != EOK) { + LOGE("memcpy returnString failed."); + HcfFree(*returnString); + return HCF_ERR_MALLOC; + } + return HCF_SUCCESS; +} + +static HcfResult GetCurveName(const HcfKey *self, bool isPriavte, char **returnString) +{ + int32_t curveId = 0; + if (isPriavte) { + curveId = ((HcfOpensslSm2PriKey *)self)->curveId; + } else { + curveId = ((HcfOpensslSm2PubKey *)self)->curveId; + } + + char *tmp = NULL; + if (curveId != NID_sm2) { + LOGE("No curve name."); + return HCF_ERR_CRYPTO_OPERATION; + } + tmp = "NID_sm2"; + + size_t len = HcfStrlen(tmp); + if (!len) { + LOGE("tmp is enpty!"); + return HCF_INVALID_PARAMS; + } + *returnString = (char *)HcfMalloc(len + 1, 0); + if (*returnString == NULL) { + LOGE("Alloc returnString memory failed."); + return HCF_ERR_MALLOC; + } + if (memcpy_s(*returnString, len, tmp, len) != EOK) { + LOGE("memcpy returnString failed."); + HcfFree(*returnString); + return HCF_ERR_MALLOC; + } + return HCF_SUCCESS; +} + +static HcfResult CheckSm2KeySelf(const HcfKey *self, bool *isPrivate) +{ + if (IsClassMatch((HcfObjectBase *)self, GetSm2PubKeyClass())) { + *isPrivate = false; + return HCF_SUCCESS; + } else if (IsClassMatch((HcfObjectBase *)self, GetSm2PriKeyClass())) { + if (((HcfOpensslSm2PriKey *)self)->ecKey == NULL) { + LOGE("Cannot use priKey after free"); + return HCF_INVALID_PARAMS; + } + *isPrivate = true; + return HCF_SUCCESS; + } else { + return HCF_INVALID_PARAMS; + } +} + +static HcfResult GetPkSkBigInteger(const HcfKey *self, bool isPrivate, + const AsyKeySpecItem item, HcfBigInteger *returnBigInteger) +{ + HcfResult ret = HCF_INVALID_PARAMS; + if (item == ECC_SK_BN) { + if (!isPrivate) { + LOGE("ecc pub key has no private key spec item"); + return ret; + } + ret = BigNumToBigInteger(Openssl_EC_KEY_get0_private_key(((HcfOpensslEccPriKey *)self)->ecKey), + returnBigInteger); + } else { + if (isPrivate) { + LOGE("ecc pri key cannot get pub key spec item"); + return ret; + } + ret = GetPubKeyXOrY(Openssl_EC_KEY_get0_group(((HcfOpensslEccPubKey *)self)->ecKey), + Openssl_EC_KEY_get0_public_key(((HcfOpensslEccPubKey *)self)->ecKey), item, returnBigInteger); + } + return ret; +} + +static HcfResult GetSm2KeySpecBigInteger(const HcfKey *self, const AsyKeySpecItem item, + HcfBigInteger *returnBigInteger) +{ + if (self == NULL || returnBigInteger == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + bool isPrivate; + HcfResult ret = CheckSm2KeySelf(self, &isPrivate); + if (ret != HCF_SUCCESS) { + LOGE("Invalid input key"); + return HCF_INVALID_PARAMS; + } + const EC_GROUP *group = NULL; + if (isPrivate) { + group = Openssl_EC_KEY_get0_group(((HcfOpensslEccPriKey *)self)->ecKey); + } else { + group = Openssl_EC_KEY_get0_group(((HcfOpensslEccPubKey *)self)->ecKey); + } + if (group == NULL) { + LOGE("get group failed"); + return HCF_INVALID_PARAMS; + } + switch (item) { + case ECC_FP_P_BN: + case ECC_A_BN: + case ECC_B_BN: + ret = GetCurveGFp(group, item, returnBigInteger); + break; + case ECC_G_X_BN: + case ECC_G_Y_BN: + ret = GetGenerator(group, item, returnBigInteger); + break; + case ECC_N_BN: + ret = GetOrder(group, returnBigInteger); + break; + case ECC_SK_BN: + case ECC_PK_X_BN: + case ECC_PK_Y_BN: + ret = GetPkSkBigInteger(self, isPrivate, item, returnBigInteger); + break; + default: + LOGE("Invalid ecc key big number spec!"); + ret = HCF_INVALID_PARAMS; + break; + } + return ret; +} + +static HcfResult GetSm2KeySpecString(const HcfKey *self, const AsyKeySpecItem item, char **returnString) +{ + if (self == NULL || returnString == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + bool isPrivate; + HcfResult ret = CheckSm2KeySelf(self, &isPrivate); + if (ret != HCF_SUCCESS) { + LOGE("Invalid input key"); + return HCF_INVALID_PARAMS; + } + + switch (item) { + case ECC_FIELD_TYPE_STR: + ret = GetFieldType(self, isPrivate, returnString); + break; + case ECC_CURVE_NAME_STR: + ret = GetCurveName(self, isPrivate, returnString); + break; + default: + ret = HCF_INVALID_PARAMS; + LOGE("Invalid spec of ec string"); + break; + } + return ret; +} + +static HcfResult GetSm2KeySpecInt(const HcfKey *self, const AsyKeySpecItem item, int *returnInt) +{ + if (self == NULL || returnInt == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + bool isPrivate; + HcfResult ret = CheckSm2KeySelf(self, &isPrivate); + if (ret != HCF_SUCCESS) { + LOGE("Invalid input key"); + return HCF_INVALID_PARAMS; + } + const EC_GROUP *group = NULL; + if (isPrivate) { + group = Openssl_EC_KEY_get0_group(((HcfOpensslEccPriKey *)self)->ecKey); + } else { + group = Openssl_EC_KEY_get0_group(((HcfOpensslEccPubKey *)self)->ecKey); + } + if (group == NULL) { + LOGE("get group failed"); + return HCF_INVALID_PARAMS; + } + switch (item) { + case ECC_H_INT: + ret = GetCofactor(group, returnInt); + break; + case ECC_FIELD_SIZE_INT: + ret = GetFieldSize(group, returnInt); + break; + default: + ret = HCF_INVALID_PARAMS; + LOGE("invalid ec key int spec"); + break; + } + return ret; +} + +static HcfResult GetSm2PubKeySpecBigInteger(const HcfPubKey *self, const AsyKeySpecItem item, + HcfBigInteger *returnBigInteger) +{ + return GetSm2KeySpecBigInteger((HcfKey *)self, item, returnBigInteger); +} + +static HcfResult GetSm2PriKeySpecBigInteger(const HcfPriKey *self, const AsyKeySpecItem item, + HcfBigInteger *returnBigInteger) +{ + return GetSm2KeySpecBigInteger((HcfKey *)self, item, returnBigInteger); +} + +static HcfResult GetSm2PubKeySpecString(const HcfPubKey *self, const AsyKeySpecItem item, char **returnString) +{ + return GetSm2KeySpecString((HcfKey *)self, item, returnString); +} + +static HcfResult GetSm2PriKeySpecString(const HcfPriKey *self, const AsyKeySpecItem item, char **returnString) +{ + return GetSm2KeySpecString((HcfKey *)self, item, returnString); +} + +static HcfResult GetSm2PubKeySpecInt(const HcfPubKey *self, const AsyKeySpecItem item, int *returnInt) +{ + return GetSm2KeySpecInt((HcfKey *)self, item, returnInt); +} + +static HcfResult GetSm2PriKeySpecInt(const HcfPriKey *self, const AsyKeySpecItem item, int *returnInt) +{ + return GetSm2KeySpecInt((HcfKey *)self, item, returnInt); +} + +static HcfResult PackSm2PubKey(int32_t curveId, EC_KEY *ecKey, const char *fieldType, + HcfOpensslSm2PubKey **returnObj) { HcfOpensslSm2PubKey *returnPubKey = (HcfOpensslSm2PubKey *)HcfMalloc(sizeof(HcfOpensslSm2PubKey), 0); if (returnPubKey == NULL) { @@ -271,19 +1149,39 @@ static HcfResult PackSm2PubKey(int32_t curveId, EC_KEY *ecKey, HcfOpensslSm2PubK return HCF_ERR_MALLOC; } + char *tmpFieldType = NULL; + if (fieldType != NULL) { + size_t len = HcfStrlen(fieldType); + if (!len) { + LOGE("fieldType is empty!"); + return HCF_INVALID_PARAMS; + } + tmpFieldType = (char *)HcfMalloc(len + 1, 0); + if (tmpFieldType == NULL) { + LOGE("Alloc tmpFieldType memory failed."); + HcfFree(returnPubKey); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(tmpFieldType, len, fieldType, len); + } returnPubKey->base.base.base.destroy = DestroySm2PubKey; returnPubKey->base.base.base.getClass = GetSm2PubKeyClass; returnPubKey->base.base.getAlgorithm = GetSm2PubKeyAlgorithm; returnPubKey->base.base.getEncoded = GetSm2PubKeyEncoded; returnPubKey->base.base.getFormat = GetSm2PubKeyFormat; + returnPubKey->base.getAsyKeySpecBigInteger = GetSm2PubKeySpecBigInteger; + returnPubKey->base.getAsyKeySpecString = GetSm2PubKeySpecString; + returnPubKey->base.getAsyKeySpecInt = GetSm2PubKeySpecInt; returnPubKey->curveId = curveId; returnPubKey->ecKey = ecKey; + returnPubKey->fieldType = tmpFieldType; *returnObj = returnPubKey; return HCF_SUCCESS; } -static HcfResult PackSm2PriKey(int32_t curveId, EC_KEY *ecKey, HcfOpensslSm2PriKey **returnObj) +static HcfResult PackSm2PriKey(int32_t curveId, EC_KEY *ecKey, const char *fieldType, + HcfOpensslSm2PriKey **returnObj) { HcfOpensslSm2PriKey *returnPriKey = (HcfOpensslSm2PriKey *)HcfMalloc(sizeof(HcfOpensslSm2PriKey), 0); if (returnPriKey == NULL) { @@ -291,14 +1189,29 @@ static HcfResult PackSm2PriKey(int32_t curveId, EC_KEY *ecKey, HcfOpensslSm2PriK return HCF_ERR_MALLOC; } + char *tmpFieldType = NULL; + if (fieldType != NULL) { + int32_t len = (int32_t)strlen(fieldType); + tmpFieldType = (char *)HcfMalloc(len + 1, 0); + if (tmpFieldType == NULL) { + LOGE("Alloc tmpFieldType memory failed."); + HcfFree(returnPriKey); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(tmpFieldType, len, fieldType, len); + } returnPriKey->base.base.base.destroy = DestroySm2PriKey; returnPriKey->base.base.base.getClass = GetSm2PriKeyClass; returnPriKey->base.base.getAlgorithm = GetSm2PriKeyAlgorithm; returnPriKey->base.base.getEncoded = GetSm2PriKeyEncoded; returnPriKey->base.base.getFormat = GetSm2PriKeyFormat; + returnPriKey->base.getAsyKeySpecBigInteger = GetSm2PriKeySpecBigInteger; + returnPriKey->base.getAsyKeySpecString = GetSm2PriKeySpecString; + returnPriKey->base.getAsyKeySpecInt = GetSm2PriKeySpecInt; returnPriKey->base.clearMem = Sm2PriKeyClearMem; returnPriKey->curveId = curveId; returnPriKey->ecKey = ecKey; + returnPriKey->fieldType = tmpFieldType; *returnObj = returnPriKey; return HCF_SUCCESS; @@ -330,7 +1243,7 @@ static HcfResult ConvertEcPubKey(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpenss HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - HcfResult ret = PackSm2PubKey(curveId, ecKey, returnPubKey); + HcfResult ret = PackSm2PubKey(curveId, ecKey, g_sm2GenerateFieldType, returnPubKey); if (ret != HCF_SUCCESS) { LOGE("CreateSm2PubKey failed."); Openssl_EC_KEY_free(ecKey); @@ -348,7 +1261,7 @@ static HcfResult ConvertEcPriKey(int32_t curveId, HcfBlob *priKeyBlob, HcfOpenss HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - HcfResult ret = PackSm2PriKey(curveId, ecKey, returnPriKey); + HcfResult ret = PackSm2PriKey(curveId, ecKey, g_sm2GenerateFieldType, returnPriKey); if (ret != HCF_SUCCESS) { Openssl_EC_KEY_free(ecKey); return ret; @@ -404,7 +1317,31 @@ static HcfResult EngineConvertSm2Key(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return HCF_SUCCESS; } -static HcfResult CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, +static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType, + EC_KEY *ecKey, HcfPubKey **returnObj) +{ + HcfOpensslSm2PubKey *pubKey = NULL; + HcfResult ret = PackSm2PubKey(impl->curveId, ecKey, fieldType, &pubKey); + if (ret != HCF_SUCCESS) { + return ret; + } + *returnObj = (HcfPubKey *)pubKey; + return HCF_SUCCESS; +} + +static HcfResult PackAndAssignPriKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType, + EC_KEY *ecKey, HcfPriKey **returnObj) +{ + HcfOpensslSm2PriKey *priKey = NULL; + HcfResult ret = PackSm2PriKey(impl->curveId, ecKey, fieldType, &priKey); + if (ret != HCF_SUCCESS) { + return ret; + } + *returnObj = (HcfPriKey *)priKey; + return HCF_SUCCESS; +} + +static HcfResult CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType, EC_KEY *ecKey, HcfKeyPair **returnObj) { EC_KEY *ecPriKey = EC_KEY_dup(ecKey); @@ -413,7 +1350,7 @@ static HcfResult CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Imp return HCF_ERR_CRYPTO_OPERATION; } HcfOpensslSm2PriKey *priKey = NULL; - HcfResult ret = PackSm2PriKey(impl->curveId, ecPriKey, &priKey); + HcfResult ret = PackSm2PriKey(impl->curveId, ecPriKey, fieldType, &priKey); if (ret != HCF_SUCCESS) { Openssl_EC_KEY_free(ecPriKey); return ret; @@ -425,7 +1362,7 @@ static HcfResult CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Imp HcfObjDestroy(priKey); return HCF_ERR_CRYPTO_OPERATION; } - ret = PackSm2PubKey(impl->curveId, ecPubKey, &pubKey); + ret = PackSm2PubKey(impl->curveId, ecPubKey, fieldType, &pubKey); if (ret != HCF_SUCCESS) { HcfObjDestroy(priKey); Openssl_EC_KEY_free(ecPubKey); @@ -456,7 +1393,7 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * EC_KEY *ecKey = NULL; HcfResult ret = NewEcKeyPair(impl->curveId, &ecKey); if (ret == HCF_SUCCESS) { - ret = CreateAndAssignKeyPair(impl, ecKey, returnObj); + ret = CreateAndAssignKeyPair(impl, g_sm2GenerateFieldType, ecKey, returnObj); if (ret != HCF_SUCCESS) { LOGE("CreateAndAssignKeyPair failed."); } @@ -465,6 +1402,155 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * return ret; } +static HcfResult GenKeyPairSm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey) +{ + HcfResult ret = HCF_INVALID_PARAMS; + switch (params->specType) { + case HCF_COMMON_PARAMS_SPEC: + ret = NewSm2KeyPairWithCommSpec((HcfEccCommParamsSpec *)params, ecKey); + break; + case HCF_KEY_PAIR_SPEC: + ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, true); + break; + default: + LOGE("Invaild input spec to gen key pair."); + break; + } + return ret; +} + +static HcfResult GenPubKeySm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey) +{ + HcfResult ret = HCF_INVALID_PARAMS; + switch (params->specType) { + case HCF_PUBLIC_KEY_SPEC: + ret = NewSm2PubKeyWithPubSpec((HcfEccPubKeyParamsSpec *)params, ecKey); + break; + case HCF_KEY_PAIR_SPEC: + ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, false); + break; + default: + LOGE("Invaild input spec to gen pub key"); + break; + } + return ret; +} + +static HcfResult GenPriKeySm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey) +{ + HcfResult ret = HCF_INVALID_PARAMS; + switch (params->specType) { + case HCF_PRIVATE_KEY_SPEC: + ret = NewSm2PriKeyWithPriSpec((HcfEccPriKeyParamsSpec *)params, ecKey); + break; + case HCF_KEY_PAIR_SPEC: + ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, true); + break; + default: + LOGE("Invaild input spec to gen pri key"); + break; + } + return ret; +} + +static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, + HcfKeyPair **returnKeyPair) +{ + if ((self == NULL) || (returnKeyPair == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) { + return HCF_INVALID_PARAMS; + } + + HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self; + EC_KEY *ecKey = NULL; + HcfResult ret = GenKeyPairSm2KeyBySpec(params, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("Gen ec key pair with spec failed."); + return ret; + } + + // curveId == 0 means no curve to match. + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + if (curveId != 0) { + impl->curveId = curveId; + } + // deep copy of ecKey, free ecKey whether it succeed or failed. + ret = CreateAndAssignKeyPair(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnKeyPair); + Openssl_EC_KEY_free(ecKey); + if (ret != HCF_SUCCESS) { + LOGE("CreateAndAssignKeyPair failed."); + return ret; + } + return HCF_SUCCESS; +} + +static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, + HcfPubKey **returnPubKey) +{ + if ((self == NULL) || (returnPubKey == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) { + return HCF_INVALID_PARAMS; + } + + HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self; + EC_KEY *ecKey = NULL; + HcfResult ret = GenPubKeySm2KeyBySpec(params, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("Gen ec pubKey with spec failed."); + return ret; + } + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + if (curveId != 0) { + impl->curveId = curveId; + } + ret = PackAndAssignPubKey(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("PackAndAssignPubKey failed."); + Openssl_EC_KEY_free(ecKey); + return ret; + } + return HCF_SUCCESS; +} + +static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, + HcfPriKey **returnPriKey) +{ + if ((self == NULL) || (returnPriKey == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!IsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) { + return HCF_INVALID_PARAMS; + } + + HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self; + EC_KEY *ecKey = NULL; + HcfResult ret = GenPriKeySm2KeyBySpec(params, &ecKey); + if (ret != HCF_SUCCESS) { + LOGE("Gen ec priKey with spec failed."); + return ret; + } + + int32_t curveId = (int32_t)Openssl_EC_GROUP_get_curve_name(Openssl_EC_KEY_get0_group(ecKey)); + if (curveId != 0) { + impl->curveId = curveId; + } + + ret = PackAndAssignPriKey(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("PackAndAssignPriKey failed."); + Openssl_EC_KEY_free(ecKey); + return ret; + } + return HCF_SUCCESS; +} + HcfResult HcfAsyKeyGeneratorSpiSm2Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj) { if (params == NULL || returnObj == NULL) { @@ -488,6 +1574,9 @@ HcfResult HcfAsyKeyGeneratorSpiSm2Create(HcfAsyKeyGenParams *params, HcfAsyKeyGe returnImpl->base.base.destroy = DestroySm2KeyPairGenerator; returnImpl->base.engineConvertKey = EngineConvertSm2Key; returnImpl->base.engineGenerateKeyPair = EngineGenerateKeyPair; + returnImpl->base.engineGenerateKeyPairBySpec = EngineGenerateKeyPairBySpec; + returnImpl->base.engineGeneratePubKeyBySpec = EngineGeneratePubKeyBySpec; + returnImpl->base.engineGeneratePriKeyBySpec = EngineGeneratePriKeyBySpec; returnImpl->curveId = curveId; *returnObj = (HcfAsyKeyGeneratorSpi *)returnImpl; diff --git a/plugin/plugin.gni b/plugin/plugin.gni index 14f63b3..30b3eb0 100644 --- a/plugin/plugin.gni +++ b/plugin/plugin.gni @@ -47,6 +47,7 @@ plugin_common_files = [ plugin_asy_key_generator_files = [ "${plugin_path}/openssl_plugin/key/asy_key_generator/src/dsa_asy_key_generator_openssl.c", "${plugin_path}/openssl_plugin/key/asy_key_generator/src/ecc_asy_key_generator_openssl.c", + "${plugin_path}/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c", "${plugin_path}/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c", "${plugin_path}/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c", ] diff --git a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp index 50c3560..d1d2bdd 100755 --- a/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp +++ b/test/fuzztest/crypto_operation/hcfsigncreate_fuzzer/hcfsigncreate_fuzzer.cpp @@ -59,9 +59,73 @@ namespace OHOS { HcfObjDestroy(sign); } + static void TestSignSm2(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *sm2256KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &sm2256KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("SM2_256|SM3", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sm2256KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, sm2256KeyPair->priKey); + (void)sign->update(sign, &mockInput); + HcfObjDestroy(sm2256KeyPair); + HcfObjDestroy(sign); + } + + static void TestSignBrainpool(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *brainPoolP160r1KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &brainPoolP160r1KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP160r1|SHA1", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(brainPoolP160r1KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, brainPoolP160r1KeyPair->priKey); + (void)sign->update(sign, &mockInput); + HcfObjDestroy(brainPoolP160r1KeyPair); + HcfObjDestroy(sign); + } + bool HcfSignCreateFuzzTest(const uint8_t* data, size_t size) { TestSign(); + TestSignSm2(); + TestSignBrainpool(); HcfSign *sign = nullptr; std::string algoName(reinterpret_cast(data), size); HcfResult res = HcfSignCreate(algoName.c_str(), &sign); diff --git a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp index b19b1ea..f537b64 100755 --- a/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp +++ b/test/fuzztest/crypto_operation/hcfverifycreate_fuzzer/hcfverifycreate_fuzzer.cpp @@ -77,9 +77,109 @@ namespace OHOS { HcfObjDestroy(verify); } + static void TestVerifySm2(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *sm2256KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &sm2256KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("SM2_256|SM3", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sm2256KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, sm2256KeyPair->priKey); + (void)sign->update(sign, &mockInput); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("SM2_256|SM3", &verify); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sm2256KeyPair); + HcfObjDestroy(sign); + return; + } + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + (void)sign->sign(sign, nullptr, &out); + (void)verify->init(verify, nullptr, sm2256KeyPair->pubKey); + (void)verify->update(verify, &mockInput); + (void)verify->verify(verify, nullptr, &out); + HcfObjDestroy(sm2256KeyPair); + HcfObjDestroy(sign); + HcfBlobDataFree(&out); + HcfObjDestroy(verify); + } + + static void TestVerifyBrainpool(void) + { + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfKeyPair *brainPoolP160r1KeyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &brainPoolP160r1KeyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + return; + } + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP160r1|SHA1", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(brainPoolP160r1KeyPair); + return; + } + static HcfBlob mockInput = { + .data = reinterpret_cast(g_mockMessage), + .len = INPUT_MSG_LEN + }; + (void)sign->init(sign, nullptr, brainPoolP160r1KeyPair->priKey); + (void)sign->update(sign, &mockInput); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA1", &verify); + if (res != HCF_SUCCESS) { + HcfObjDestroy(brainPoolP160r1KeyPair); + HcfObjDestroy(sign); + return; + } + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + (void)sign->sign(sign, nullptr, &out); + (void)verify->init(verify, nullptr, brainPoolP160r1KeyPair->pubKey); + (void)verify->update(verify, &mockInput); + (void)verify->verify(verify, nullptr, &out); + HcfObjDestroy(brainPoolP160r1KeyPair); + HcfObjDestroy(sign); + HcfBlobDataFree(&out); + HcfObjDestroy(verify); + } + bool HcfVerifyCreateFuzzTest(const uint8_t* data, size_t size) { TestVerify(); + TestVerifySm2(); + TestVerifyBrainpool(); HcfVerify *verify = nullptr; std::string algoName(reinterpret_cast(data), size); HcfResult res = HcfVerifyCreate(algoName.c_str(), &verify); diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp index 2737b20..0d8efdf 100644 --- a/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp +++ b/test/fuzztest/key/asykeygenerator_fuzzer/asykeygenerator_fuzzer.cpp @@ -26,11 +26,22 @@ #include "detailed_rsa_key_params.h" #include "ecc_openssl_common.h" #include "ecc_common.h" +#include "ecc_key_util.h" +#include "key_utils.h" #include "result.h" using namespace std; +namespace { +HcfEccCommParamsSpec *g_sm2256CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpoolP160r1CommSpec = nullptr; +} + namespace OHOS { + HcfEccPubKeyParamsSpec g_ecc256PubKeySpec; + HcfEccPriKeyParamsSpec g_ecc256PriKeySpec; + HcfEccKeyPairParamsSpec g_ecc256KeyPairSpec; + enum class GenerateType { FUZZ_COMMON = 0, FUZZ_PUBKEY = 1, @@ -40,6 +51,10 @@ namespace OHOS { static bool g_testFlag = true; static const int ECC224_PUB_KEY_LEN = 80; static const int ECC224_PRI_KEY_LEN = 44; + static const int SM2256_PUB_KEY_LEN = 91; + static const int SM2256_PRI_KEY_LEN = 51; + static const int BRAINPOOLP160R1_PUB_KEY_LEN = 68; + static const int BRAINPOOLP160R1_PRI_KEY_LEN = 40; 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, @@ -49,6 +64,25 @@ namespace OHOS { 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 uint8_t g_mockSm2256PubKey[SM2256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8, + 42, 129, 28, 207, 85, 1, 130, 45, 3, 66, 0, 4, 84, 128, 137, 18, 201, 132, 210, 60, 20, 222, 30, 185, 219, 9, + 72, 46, 148, 231, 101, 110, 21, 148, 127, 148, 90, 64, 20, 254, 155, 69, 61, 249, 46, 238, 158, 218, 72, 159, + 102, 22, 2, 54, 42, 255, 37, 96, 92, 193, 152, 172, 86, 64, 228, 244, 125, 115, 97, 211, 232, 74, 79, 25, + 217, 239 }; + + static uint8_t g_mockSm2256PriKey[SM2256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 78, 6, 176, 182, 178, 223, 78, + 63, 118, 13, 15, 35, 44, 56, 78, 69, 212, 192, 65, 232, 103, 124, 247, 30, 211, 81, 139, 187, 28, 165, 8, 248, + 160, 10, 6, 8, 42, 129, 28, 207, 85, 1, 130, 45 }; + + static uint8_t g_mockBrainpoolPubKey[BRAINPOOLP160R1_PUB_KEY_LEN] = { 48, 66, 48, 20, 6, 7, 42, 134, 72, 206, 61, + 2, 1, 6, 9, 43, 36, 3, 3, 2, 8, 1, 1, 1, 3, 42, 0, 4, 37, 67, 178, 178, 176, 241, 23, 119, 74, 231, 82, 88, + 215, 227, 37, 24, 129, 177, 152, 142, 144, 155, 44, 97, 145, 114, 242, 156, 129, 225, 186, 196, 113, 41, 198, + 85, 186, 69, 198, 146 }; + + static uint8_t g_mockBrainpoolPriKey[BRAINPOOLP160R1_PRI_KEY_LEN] = { 48, 38, 2, 1, 1, 4, 20, 116, 221, 96, 238, + 46, 76, 111, 184, 30, 42, 223, 86, 187, 131, 127, 41, 28, 223, 93, 134, 160, 11, 6, 9, 43, 36, 3, 3, 2, 8, 1, + 1, 1 }; + constexpr uint32_t DSA2048_PRI_SIZE = 20; constexpr uint32_t DSA2048_PUB_SIZE = 256; constexpr uint32_t DSA2048_P_SIZE = 256; @@ -404,7 +438,6 @@ namespace OHOS { returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; } - static HcfResult ConstructEcc224CommParamsSpec(HcfAsyKeyParamsSpec **spec) { HcfEccCommParamsSpec *eccCommSpec = &g_ecc224CommSpec; @@ -414,7 +447,8 @@ namespace OHOS { eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC; eccCommSpec->field = tmpField; eccCommSpec->field->fieldType = const_cast(g_eccFieldType.c_str()); - ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP); + ((HcfECFieldFp *)(eccCommSpec->field))->p.data = + (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP); ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_secp224r1_len; eccCommSpec->a.data = (IsBigEndian() ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA); eccCommSpec->a.len = NID_secp224r1_len; @@ -528,6 +562,142 @@ namespace OHOS { return HCF_SUCCESS; } + static HcfResult ConstructSm2256CommParamsSpec(const std::string &algoName, HcfEccCommParamsSpec **spec) + { + HcfEccCommParamsSpec *eccCommSpec = nullptr; + + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + + *spec = eccCommSpec; + return HCF_SUCCESS; + } + + static HcfResult ConstructSm2256PubKeyParamsSpec(const std::string &algoName, + HcfEccCommParamsSpec *eccCommParamsSpec, HcfAsyKeyParamsSpec **spec) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPubKeyParamsSpec *eccPubKeySpec = &g_ecc256PubKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPubKeySpec->base.base.algName = eccCommParamsSpec->base.algName; + eccPubKeySpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccPubKeySpec->base.field = eccCommParamsSpec->field; + eccPubKeySpec->base.field->fieldType = eccCommParamsSpec->field->fieldType; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.data = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.data; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.len = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.len; + eccPubKeySpec->base.a.data = eccCommParamsSpec->a.data; + eccPubKeySpec->base.a.len = eccCommParamsSpec->a.len; + eccPubKeySpec->base.b.data = eccCommParamsSpec->b.data; + eccPubKeySpec->base.b.len = eccCommParamsSpec->b.len; + eccPubKeySpec->base.g.x.data = eccCommParamsSpec->g.x.data; + eccPubKeySpec->base.g.x.len = eccCommParamsSpec->g.x.len; + eccPubKeySpec->base.g.y.data = eccCommParamsSpec->g.y.data; + eccPubKeySpec->base.g.y.len = eccCommParamsSpec->g.y.len; + eccPubKeySpec->base.n.data = eccCommParamsSpec->n.data; + eccPubKeySpec->base.n.len = eccCommParamsSpec->n.len; + eccPubKeySpec->base.h = eccCommParamsSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccPubKeySpec->pk.x.data = retBigInt.data; + eccPubKeySpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccPubKeySpec->pk.y.data =retBigInt.data; + eccPubKeySpec->pk.y.len = retBigInt.len; + + *spec = reinterpret_cast(eccPubKeySpec); + HcfObjDestroy(generator); + return HCF_SUCCESS; + } + + static HcfResult ConstructSm2256PriKeyParamsSpec(const std::string &algoName, + HcfEccCommParamsSpec *eccCommParamsSpec, HcfAsyKeyParamsSpec **spec) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPriKeyParamsSpec *eccPriKeySpec = &g_ecc256PriKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPriKeySpec->base.base.algName = eccCommParamsSpec->base.algName; + eccPriKeySpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccPriKeySpec->base.field = eccCommParamsSpec->field; + eccPriKeySpec->base.field->fieldType = eccCommParamsSpec->field->fieldType; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.data = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.data; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.len = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.len; + eccPriKeySpec->base.a.data = eccCommParamsSpec->a.data; + eccPriKeySpec->base.a.len = eccCommParamsSpec->a.len; + eccPriKeySpec->base.b.data = eccCommParamsSpec->b.data; + eccPriKeySpec->base.b.len = eccCommParamsSpec->b.len; + eccPriKeySpec->base.g.x.data = eccCommParamsSpec->g.x.data; + eccPriKeySpec->base.g.x.len = eccCommParamsSpec->g.x.len; + eccPriKeySpec->base.g.y.data = eccCommParamsSpec->g.y.data; + eccPriKeySpec->base.g.y.len = eccCommParamsSpec->g.y.len; + eccPriKeySpec->base.n.data = eccCommParamsSpec->n.data; + eccPriKeySpec->base.n.len = eccCommParamsSpec->n.len; + eccPriKeySpec->base.h = eccCommParamsSpec->h; + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccPriKeySpec->sk.data = retBigInt.data; + eccPriKeySpec->sk.len = retBigInt.len; + + *spec = reinterpret_cast(eccPriKeySpec); + HcfObjDestroy(generator); + return HCF_SUCCESS; + } + + static HcfResult ConstructSm2256KeyPairParamsSpec(const std::string &algoName, + HcfEccCommParamsSpec *eccCommParamsSpec, HcfAsyKeyParamsSpec **spec) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc256KeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = eccCommParamsSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = eccCommParamsSpec->field; + eccKeyPairSpec->base.field->fieldType = eccCommParamsSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(eccCommParamsSpec->field))->p.len; + eccKeyPairSpec->base.a.data = eccCommParamsSpec->a.data; + eccKeyPairSpec->base.a.len = eccCommParamsSpec->a.len; + eccKeyPairSpec->base.b.data = eccCommParamsSpec->b.data; + eccKeyPairSpec->base.b.len = eccCommParamsSpec->b.len; + eccKeyPairSpec->base.g.x.data = eccCommParamsSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = eccCommParamsSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = eccCommParamsSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = eccCommParamsSpec->g.y.len; + eccKeyPairSpec->base.n.data = eccCommParamsSpec->n.data; + eccKeyPairSpec->base.n.len = eccCommParamsSpec->n.len; + eccKeyPairSpec->base.h = eccCommParamsSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = reinterpret_cast(eccKeyPairSpec); + HcfObjDestroy(generator); + return HCF_SUCCESS; + } + static void TestEccKey(void) { HcfAsyKeyGenerator *generator = nullptr; @@ -622,6 +792,67 @@ namespace OHOS { HcfObjDestroy(dupKeyPair); } + static void TestSm2Key(void) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &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_mockSm2256PubKey, + .len = SM2256_PUB_KEY_LEN + }; + + static HcfBlob mockEcc224PriKeyBlob = { + .data = g_mockSm2256PriKey, + .len = SM2256_PRI_KEY_LEN + }; + (void)generator->convertKey(generator, nullptr, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &convertKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(convertKeyPair); + } + + static void TestBrainpoolKey(void) + { + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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 mockBrainpoolPubKeyBlob = { + .data = g_mockBrainpoolPubKey, + .len = BRAINPOOLP160R1_PUB_KEY_LEN + }; + + static HcfBlob mockBrainpoolPriKeyBlob = { + .data = g_mockBrainpoolPriKey, + .len = BRAINPOOLP160R1_PRI_KEY_LEN + }; + (void)generator->convertKey(generator, nullptr, &mockBrainpoolPubKeyBlob, &mockBrainpoolPriKeyBlob, + &convertKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(convertKeyPair); + } + static void GenEccKeyBySpec(GenerateType type) { HcfAsyKeyParamsSpec *paramSpec = nullptr; @@ -686,7 +917,8 @@ namespace OHOS { switch (type) { case GenerateType::FUZZ_COMMON: GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec); - res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(&rsaCommSpec), &generator); + res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(&rsaCommSpec), + &generator); break; case GenerateType::FUZZ_PUBKEY: GenerateRsa2048CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec); @@ -695,7 +927,8 @@ namespace OHOS { break; case GenerateType::FUZZ_KEYPAIR: GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec); - res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(&rsaPairSpec), &generator); + res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(&rsaPairSpec), + &generator); break; default: return; @@ -760,15 +993,100 @@ namespace OHOS { GenDsaKeyBySpec(GenerateType::FUZZ_PUBKEY); GenDsaKeyBySpec(GenerateType::FUZZ_KEYPAIR); } + + static void GenSm2KeyBySpec(GenerateType type, const std::string &algoName, + HcfEccCommParamsSpec *eccCommParamsSpec) + { + HcfAsyKeyParamsSpec *paramSpec = nullptr; + HcfAsyKeyGeneratorBySpec *generator = nullptr; + HcfKeyPair *keyPair = nullptr; + HcfPriKey *priKey = nullptr; + HcfPubKey *pubKey = nullptr; + int32_t res = HCF_SUCCESS; + switch (type) { + case GenerateType::FUZZ_PRIKEY: + res = ConstructSm2256PriKeyParamsSpec(algoName, eccCommParamsSpec, ¶mSpec); + break; + case GenerateType::FUZZ_PUBKEY: + res = ConstructSm2256PubKeyParamsSpec(algoName, eccCommParamsSpec, ¶mSpec); + break; + case GenerateType::FUZZ_KEYPAIR: + res = ConstructSm2256KeyPairParamsSpec(algoName, eccCommParamsSpec, ¶mSpec); + break; + default: + return; + } + if (res != HCF_SUCCESS) { + return; + } + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + if (res != HCF_SUCCESS) { + return; + } + (void)generator->generateKeyPair(generator, &keyPair); + (void)generator->generatePriKey(generator, &priKey); + (void)generator->generatePubKey(generator, &pubKey); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(priKey); + HcfObjDestroy(pubKey); + } + + static void GenSm2KeyCommonBySpec(HcfEccCommParamsSpec *eccCommSpec) + { + HcfAsyKeyGeneratorBySpec *generator = nullptr; + HcfKeyPair *keyPair = nullptr; + HcfPriKey *priKey = nullptr; + HcfPubKey *pubKey = nullptr; + int32_t res = HCF_SUCCESS; + res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(eccCommSpec), &generator); + if (res != HCF_SUCCESS) { + return; + } + (void)generator->generateKeyPair(generator, &keyPair); + (void)generator->generatePriKey(generator, &priKey); + (void)generator->generatePubKey(generator, &pubKey); + HcfObjDestroy(generator); + HcfObjDestroy(keyPair); + HcfObjDestroy(priKey); + HcfObjDestroy(pubKey); + } + + static void TestSm2KeyBySpec(void) + { + ConstructSm2256CommParamsSpec("NID_sm2", &g_sm2256CommSpec); + GenSm2KeyCommonBySpec(g_sm2256CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_PRIKEY, "SM2_256", g_sm2256CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_PUBKEY, "SM2_256", g_sm2256CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_KEYPAIR, "SM2_256", g_sm2256CommSpec); + FreeEccCommParamsSpec(g_sm2256CommSpec); + g_sm2256CommSpec = nullptr; + } + + static void TestBrainpoolKeyBySpec(void) + { + ConstructSm2256CommParamsSpec("NID_brainpoolP160r1", &g_brainpoolP160r1CommSpec); + GenSm2KeyCommonBySpec(g_brainpoolP160r1CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_PRIKEY, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_PUBKEY, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec); + GenSm2KeyBySpec(GenerateType::FUZZ_KEYPAIR, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec); + FreeEccCommParamsSpec(g_brainpoolP160r1CommSpec); + g_brainpoolP160r1CommSpec = nullptr; + } + bool AsyKeyGeneratorFuzzTest(const uint8_t* data, size_t size) { if (g_testFlag) { TestEccKey(); TestRsaKey(); TestDsaKey(); + TestSm2Key(); + TestBrainpoolKey(); TestEccKeyBySpec(); TestRsaKeyBySpec(); TestDsaKeyBySpec(); + TestSm2KeyBySpec(); + TestBrainpoolKeyBySpec(); g_testFlag = false; } HcfAsyKeyGenerator *generator = nullptr; diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/BUILD.gn b/test/fuzztest/key/ecckeyutil_fuzzer/BUILD.gn new file mode 100644 index 0000000..d932eb1 --- /dev/null +++ b/test/fuzztest/key/ecckeyutil_fuzzer/BUILD.gn @@ -0,0 +1,56 @@ +# 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. + +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_framework" + +##############################fuzztest########################################## +ohos_fuzztest("EccKeyUtilFuzzTest") { + module_out_path = module_output_path + fuzz_config_file = "../ecckeyutil_fuzzer" + include_dirs = framework_inc_path + include_dirs += [ "//base/security/crypto_framework/test/unittest/include/" ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ "ecckeyutil_fuzzer.cpp" ] + deps = [ + "//third_party/bounds_checking_function:libsec_shared", + "//third_party/openssl:libcrypto_shared", + ] + + external_deps = [ + "c_utils:utils", + "crypto_framework:crypto_framework_lib", + "hilog:libhilog", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":EccKeyUtilFuzzTest", + ] +} +############################################################################### diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init b/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init new file mode 100644 index 0000000..23e26fe --- /dev/null +++ b/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# 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. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.cpp b/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.cpp new file mode 100644 index 0000000..4f6c973 --- /dev/null +++ b/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.cpp @@ -0,0 +1,86 @@ +/* + * 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 "ecckeyutil_fuzzer.h" + +#include +#include +#include + +#include "ecc_key_util.h" +#include "blob.h" +#include "detailed_ecc_key_params.h" +#include "result.h" + +using namespace std; + +namespace OHOS { + static bool g_testFlag = true; + static void TestEccKey(void) + { + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; + int32_t res = HcfEccKeyUtilCreate("NID_secp224r1", &returnCommonParamSpec); + if (res != HCF_SUCCESS) { + return; + } + FreeEccCommParamsSpec(returnCommonParamSpec); + } + + static void TestSm2Key(void) + { + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; + int32_t res = HcfEccKeyUtilCreate("NID_sm2", &returnCommonParamSpec); + if (res != HCF_SUCCESS) { + return; + } + FreeEccCommParamsSpec(returnCommonParamSpec); + } + + static void TestBrainpoolKey(void) + { + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec); + if (res != HCF_SUCCESS) { + return; + } + FreeEccCommParamsSpec(returnCommonParamSpec); + } + + bool EccKeyUtilFuzzTest(const uint8_t* data, size_t size) + { + if (g_testFlag) { + TestEccKey(); + TestSm2Key(); + TestBrainpoolKey(); + g_testFlag = false; + } + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; + std::string algoName(reinterpret_cast(data), size); + HcfResult res = HcfEccKeyUtilCreate(algoName.c_str(), &returnCommonParamSpec); + if (res != HCF_SUCCESS) { + return false; + } + FreeEccCommParamsSpec(returnCommonParamSpec); + return true; + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::EccKeyUtilFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.h b/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.h new file mode 100644 index 0000000..6754991 --- /dev/null +++ b/test/fuzztest/key/ecckeyutil_fuzzer/ecckeyutil_fuzzer.h @@ -0,0 +1,21 @@ +/* + * 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 ECC_KEY_UTIL_FUZZER_H +#define ECC_KEY_UTIL_FUZZER_H + +#define FUZZ_PROJECT_NAME "ecckeyutil_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/project.xml b/test/fuzztest/key/ecckeyutil_fuzzer/project.xml new file mode 100644 index 0000000..e8173d6 --- /dev/null +++ b/test/fuzztest/key/ecckeyutil_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index e0ce066..54a7013 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -28,6 +28,7 @@ ohos_unittest("crypto_framework_test") { "//third_party/openssl/include/", "../../plugin/openssl_plugin/key/asy_key_generator/src", "../../plugin/openssl_plugin/crypto_operation/signature/src", + "../../interfaces/innerkits/key/", ] include_dirs += framework_inc_path + plugin_inc_path + crypto_framwork_common_inc_path @@ -36,6 +37,10 @@ ohos_unittest("crypto_framework_test") { "src/crypto_3des_cipher_test.cpp", "src/crypto_aes_cipher_test.cpp", "src/crypto_asy_key_generator_cov_test.cpp", + "src/crypto_brainpool_asy_key_generator_test.cpp", + "src/crypto_brainpool_key_agreement_test.cpp", + "src/crypto_brainpool_no_length_sign_test.cpp", + "src/crypto_brainpool_no_length_verify_test.cpp", "src/crypto_common_cov_test.cpp", "src/crypto_dsa_asy_key_generator_by_spec_test.cpp", "src/crypto_dsa_asy_key_generator_test.cpp", @@ -46,6 +51,7 @@ ohos_unittest("crypto_framework_test") { "src/crypto_ecc_asy_key_generator_test.cpp", "src/crypto_ecc_key_agreement_by_spec_test.cpp", "src/crypto_ecc_key_agreement_test.cpp", + "src/crypto_ecc_key_util_test.cpp", "src/crypto_ecc_no_length_sign_test.cpp", "src/crypto_ecc_no_length_verify_test.cpp", "src/crypto_ecc_sign_test.cpp", @@ -62,6 +68,7 @@ ohos_unittest("crypto_framework_test") { "src/crypto_rsa_sign_test.cpp", "src/crypto_rsa_verify_test.cpp", "src/crypto_signature_exception_test.cpp", + "src/crypto_sm2_asy_key_generator_by_spec_test.cpp", "src/crypto_sm2_asy_key_generator_test.cpp", "src/crypto_sm2_cipher_test.cpp", "src/crypto_sm2_sign_test.cpp", diff --git a/test/unittest/src/crypto_brainpool_asy_key_generator_test.cpp b/test/unittest/src/crypto_brainpool_asy_key_generator_test.cpp new file mode 100644 index 0000000..5859e65 --- /dev/null +++ b/test/unittest/src/crypto_brainpool_asy_key_generator_test.cpp @@ -0,0 +1,2090 @@ +/* + * 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 +#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" +#include "ecc_key_util.h" +#include "key_utils.h" +#include "key_pair.h" +#include "object_base.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoBrainPoolAsyKeyGeneratorTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void CryptoBrainPoolAsyKeyGeneratorTest::TearDownTestCase() {} +void CryptoBrainPoolAsyKeyGeneratorTest::SetUp() {} +void CryptoBrainPoolAsyKeyGeneratorTest::TearDown() {} + +HcfBlob g_mockECC_BrainPool160r1PriKeyBlob = { + .data = nullptr, + .len = 0 +}; + +HcfBlob g_mockECC_BrainPool160r1PubKeyBlob = { + .data = nullptr, + .len = 0 +}; + +static const char *GetMockClass(void) +{ + return "HcfSymKeyGenerator"; +} + +HcfObjectBase g_obj = { + .getClass = GetMockClass, + .destroy = nullptr +}; + +static void ECC_BrainPool160r1KeyBlob(HcfBlob * priblob, HcfBlob *pubblob) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockECC_BrainPool160r1PriKeyBlob); + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockECC_BrainPool160r1PubKeyBlob); +} + +void CryptoBrainPoolAsyKeyGeneratorTest::SetUpTestCase() +{ + ECC_BrainPool160r1KeyBlob(&g_mockECC_BrainPool160r1PriKeyBlob, &g_mockECC_BrainPool160r1PubKeyBlob); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_2, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_3, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP192r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_4, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP192t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_5, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP224r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_6, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP224t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_7, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP256r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_8, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP256t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_9, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP320r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_10, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP320t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_11, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP384r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_12, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP384t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_13, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP512r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest001_14, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP512t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest002, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *className = generator->base.getClass(); + ASSERT_NE(className, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest003, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160t1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + generator->base.destroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest004, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + generator->base.destroy(nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest005, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + generator->base.destroy(&g_obj); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest006, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgoName(generator); + ASSERT_NE(algName, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest007, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgoName(nullptr); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest008, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest009, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest010, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(nullptr, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(keyPair, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest011, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(keyPair, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest012, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generateKeyPair(generator, nullptr, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest013, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->base.getClass(); + ASSERT_NE(className, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest014, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest015, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest016, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy(&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest017, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->pubKey->base.base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest018, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest019, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest020, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy(&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest021, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(&(keyPair->pubKey->base)); + ASSERT_NE(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest022, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(nullptr); + ASSERT_EQ(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest023, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 *)&g_obj); + ASSERT_EQ(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest024, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(&(keyPair->pubKey->base)); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest025, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(nullptr); + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest026, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 *)&g_obj); + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest027, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest028, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest029, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest030, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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), nullptr); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest031, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(keyPair->priKey); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest032, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest033, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest034, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.base.getClass(); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest035, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest036, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest037, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest038, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(&keyPair->priKey->base); + ASSERT_NE(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest039, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(nullptr); + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest040, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 *)&g_obj); + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest041, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(&(keyPair->pubKey->base)); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest042, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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(nullptr); + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest043, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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 *)&g_obj); + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest044, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest045, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest046, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest047, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + 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), nullptr); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest048, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &outKeyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outKeyPair, nullptr); + + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest049, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(nullptr, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &outKeyPair); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(outKeyPair, nullptr); + + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest050, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &outKeyPair); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(outKeyPair, nullptr); + + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest051, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(nullptr, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &outKeyPair); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(outKeyPair, nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest052, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, &g_mockECC_BrainPool160r1PriKeyBlob, &outKeyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outKeyPair, nullptr); + + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest053, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, nullptr, nullptr, &outKeyPair); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(outKeyPair, nullptr); + + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest054, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest055, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest056, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest057, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy(nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest058, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + keyPair->base.destroy(&g_obj); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest059, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->pubKey->base.base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest060, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base))); + keyPair->pubKey = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest061, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + keyPair->pubKey->base.base.destroy(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest062, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + keyPair->pubKey->base.base.destroy(&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest063, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base)); + ASSERT_NE(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest064, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat(nullptr); + ASSERT_EQ(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest065, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); + ASSERT_EQ(format, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest066, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base)); + ASSERT_NE(algName, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest067, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest068, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest069, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest070, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest071, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest072, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest073, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(keyPair->priKey); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest074, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest075, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest076, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.base.getClass(); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest077, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base))); + keyPair->priKey = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest078, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(nullptr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest079, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(&g_obj); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest080, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base); + ASSERT_NE(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest081, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat(nullptr); + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest082, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest083, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest084, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.getAlgorithm(nullptr); + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest085, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest086, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest087, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest088, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest089, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest090, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob, + &g_mockECC_BrainPool160r1PriKeyBlob, &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); + + HcfBlob priKeyBlob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outKeyPair, nullptr); + + HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPubKeyBlob.data, nullptr); + ASSERT_NE(outPubKeyBlob.len, 0); + + HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPriKeyBlob.data, nullptr); + ASSERT_NE(outPriKeyBlob.len, 0); + + free(pubKeyBlob.data); + free(priKeyBlob.data); + free(outPubKeyBlob.data); + free(outPriKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest091, 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); +} + +HWTEST_F(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest092, 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(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest093, 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(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest094, 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(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest095, 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 (uint32_t i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfAsyKeyGenerator *tmpGenerator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest096, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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 (uint32_t i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfAsyKeyGenerator *tmpGenerator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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(CryptoBrainPoolAsyKeyGeneratorTest, CryptoBrainPoolAsyKeyGeneratorTest097, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &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(); +} +} \ No newline at end of file diff --git a/test/unittest/src/crypto_brainpool_key_agreement_test.cpp b/test/unittest/src/crypto_brainpool_key_agreement_test.cpp new file mode 100644 index 0000000..472dedf --- /dev/null +++ b/test/unittest/src/crypto_brainpool_key_agreement_test.cpp @@ -0,0 +1,423 @@ +/* + * 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 +#include "securec.h" + +#include "asy_key_generator.h" +#include "detailed_ecc_key_params.h" +#include "ecdh_openssl.h" +#include "key_agreement.h" +#include "ecc_key_util.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "params_parser.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoBrainPoolKeyAgreementTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void CryptoBrainPoolKeyAgreementTest::SetUp() {} +void CryptoBrainPoolKeyAgreementTest::TearDown() {} + +static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1"; +HcfEccCommParamsSpec *g_eccCommSpec = nullptr; +HcfEccKeyPairParamsSpec g_brainpool160r1KeyPairSpec; + +static const char *GetMockClass(void) +{ + return "HcfSymKeyGenerator"; +} + +static HcfObjectBase obj = { + .getClass = GetMockClass, + .destroy = nullptr +}; + +static HcfResult ConstructEccBrainPool160r1KeyPairCommParamsSpec(const string &algoName, HcfEccCommParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = nullptr; + + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + + *spec = eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult Constructbrainpool160r1KeyPairParamsSpec(const string &algoName, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_brainpool160r1KeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = g_eccCommSpec->field; + eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccKeyPairSpec->base.a.data = g_eccCommSpec->a.data; + eccKeyPairSpec->base.a.len = g_eccCommSpec->a.len; + eccKeyPairSpec->base.b.data = g_eccCommSpec->b.data; + eccKeyPairSpec->base.b.len = g_eccCommSpec->b.len; + eccKeyPairSpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccKeyPairSpec->base.n.data = g_eccCommSpec->n.data; + eccKeyPairSpec->base.n.len = g_eccCommSpec->n.len; + eccKeyPairSpec->base.h = g_eccCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +void CryptoBrainPoolKeyAgreementTest::SetUpTestCase() +{ + ConstructEccBrainPool160r1KeyPairCommParamsSpec("NID_brainpoolP160r1", &g_eccCommSpec); +} + +void CryptoBrainPoolKeyAgreementTest::TearDownTestCase() +{ + FreeEccCommParamsSpec(g_eccCommSpec); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest001, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest002, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate(nullptr, &keyAgreement); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(keyAgreement, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest003, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD" + "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &keyAgreement); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(keyAgreement, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest004, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("SM257", &keyAgreement); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(keyAgreement, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest005, TestSize.Level0) +{ + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP512t1", nullptr); + ASSERT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest006, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + const char *className = keyAgreement->base.getClass(); + ASSERT_NE(className, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest007, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + keyAgreement->base.destroy((HcfObjectBase *)keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest008, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + keyAgreement->base.destroy(nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest009, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + keyAgreement->base.destroy(&obj); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest010, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + const char *algName = keyAgreement->getAlgoName(keyAgreement); + ASSERT_NE(algName, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest011, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + const char *algName = keyAgreement->getAlgoName(nullptr); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest012, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj)); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(keyAgreement); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest013, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair->pubKey, &out); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(keyAgreement); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest014, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = keyAgreement->generateSecret(nullptr, keyPair->priKey, keyPair->pubKey, &out); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(keyAgreement); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest015, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, nullptr, &out); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(keyAgreement); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest016, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = keyAgreement->generateSecret(keyAgreement, nullptr, keyPair->pubKey, &out); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(keyAgreement); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest017, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair->pubKey, nullptr); + ASSERT_NE(res, HCF_SUCCESS); + HcfObjDestroy(keyAgreement); + HcfObjDestroy(generator); +} +} diff --git a/test/unittest/src/crypto_brainpool_no_length_sign_test.cpp b/test/unittest/src/crypto_brainpool_no_length_sign_test.cpp new file mode 100644 index 0000000..19d7113 --- /dev/null +++ b/test/unittest/src/crypto_brainpool_no_length_sign_test.cpp @@ -0,0 +1,983 @@ +/* + * 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 +#include + +#include "asy_key_generator.h" +#include "ecc_key_util.h" +#include "key_utils.h" +#include "blob.h" +#include "detailed_ecc_key_params.h" +#include "ecc_openssl_common.h" +#include "ecc_common.h" +#include "ecdsa_openssl.h" +#include "memory.h" +#include "securec.h" +#include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "openssl_common.h" +#include "object_base.h" +#include "ecc_common_param_spec_generator_openssl.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoBrainPoolNoLengthSignTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1"; +static string g_brainpool160r1curveName = "NID_brainpoolP160r1"; + +HcfEccCommParamsSpec *g_eccCommSpec = nullptr; +HcfEccKeyPairParamsSpec g_brainpool160r1KeyPairSpec; + +void CryptoBrainPoolNoLengthSignTest::SetUp() {} +void CryptoBrainPoolNoLengthSignTest::TearDown() {} + +static const char *g_mockMessage = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 12 +}; + +static const char *GetMockClass(void) +{ + return "HcfSymKeyGenerator"; +} + +HcfObjectBase obj = { + .getClass = GetMockClass, + .destroy = nullptr +}; + +static HcfResult ConstructEccBrainPool160r1KeyPairCommParamsSpec(const string &algoName, HcfEccCommParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = nullptr; + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + *spec = eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult Constructbrainpool160r1KeyPairParamsSpec(const string &algoName, const string &curveName, + HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_brainpool160r1KeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = g_eccCommSpec->field; + eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccKeyPairSpec->base.a.data = g_eccCommSpec->a.data; + eccKeyPairSpec->base.a.len = g_eccCommSpec->a.len; + eccKeyPairSpec->base.b.data = g_eccCommSpec->b.data; + eccKeyPairSpec->base.b.len = g_eccCommSpec->b.len; + eccKeyPairSpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccKeyPairSpec->base.n.data = g_eccCommSpec->n.data; + eccKeyPairSpec->base.n.len = g_eccCommSpec->n.len; + eccKeyPairSpec->base.h = g_eccCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +void CryptoBrainPoolNoLengthSignTest::SetUpTestCase() +{ + ConstructEccBrainPool160r1KeyPairCommParamsSpec("NID_brainpoolP160r1", &g_eccCommSpec); +} + +void CryptoBrainPoolNoLengthSignTest::TearDownTestCase() +{ + FreeEccCommParamsSpec(g_eccCommSpec); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_1, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA1", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_2, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_3, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_4, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA384", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_5, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA512", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_6, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|MD5", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest002, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + const char *className = sign->base.getClass(); + ASSERT_NE(className, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest003, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + sign->base.destroy((HcfObjectBase *)sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest004, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + sign->base.destroy(nullptr); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest005, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + sign->base.destroy(&obj); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest006, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + const char *algName = sign->getAlgoName(sign); + ASSERT_NE(algName, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest007, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + const char *algName = sign->getAlgoName(nullptr); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest008, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + const char *algName = sign->getAlgoName((HcfSign *)&obj); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest009, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest010, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(nullptr, nullptr, keyPair->priKey); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest011, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init((HcfSign *)(&obj), nullptr, keyPair->priKey); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest012, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest013, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest014, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|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(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest015, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, (HcfPriKey *)(&obj)); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 1 + }; + res = sign->update(sign, &g_mockInput); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest016, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, (HcfPriKey *)(&obj)); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 1 + }; + res = sign->update(nullptr, &g_mockInput); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest017, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, (HcfPriKey *)(&obj)); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 1 + }; + + res = sign->update((HcfSign *)(&obj), &g_mockInput); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest018, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 1 + }; + + res = sign->update(sign, &g_mockInput); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + HcfObjDestroy(sign); +} + + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest019, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest020, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob input = { + .data = nullptr, + .len = 1 + }; + + res = sign->update(sign, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest021, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob input = { + .data = (uint8_t *)g_mockMessage, + .len = 0 + }; + + res = sign->update(sign, &input); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest022, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest023, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + 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); + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest024, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(nullptr, nullptr, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest025, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign((HcfSign *)(&obj), nullptr, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest026, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, nullptr, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest027, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob input = { + .data = nullptr, + .len = 1 + }; + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, &input, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest028, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob input = { + .data = (uint8_t *)g_mockMessage, + .len = 0 + }; + HcfBlob out = { + .data = nullptr, + .len = 0 + }; + res = sign->sign(sign, &input, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(out.data, nullptr); + ASSERT_EQ(out.len, (const unsigned int)0); + + HcfObjDestroy(sign); + HcfObjDestroy(generator); +} + +HcfSignatureParams g_params = { + .algo = HCF_ALG_ECC, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, +}; + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest029, TestSize.Level0) +{ + int32_t res = HcfSignSpiEcdsaCreate(&g_params, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest030, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest031, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest032, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest033, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest034, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest035, TestSize.Level0) +{ + HcfSignSpi *spiObj = nullptr; + int32_t res = HcfSignSpiEcdsaCreate(&g_params, &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); +} +} diff --git a/test/unittest/src/crypto_brainpool_no_length_verify_test.cpp b/test/unittest/src/crypto_brainpool_no_length_verify_test.cpp new file mode 100644 index 0000000..420708e --- /dev/null +++ b/test/unittest/src/crypto_brainpool_no_length_verify_test.cpp @@ -0,0 +1,1337 @@ +/* + * 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 +#include + +#include "asy_key_generator.h" +#include "ecc_key_util.h" +#include "key_utils.h" +#include "blob.h" +#include "detailed_ecc_key_params.h" +#include "ecc_openssl_common.h" +#include "ecc_common.h" +#include "ecdsa_openssl.h" +#include "memory.h" +#include "securec.h" +#include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "openssl_common.h" +#include "signature.h" +#include "pub_key.h" + +using namespace std; +using namespace testing::ext; +namespace { +class CryptoBrainPoolNoLengthVerifyTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1"; +static string g_brainpool160r1curveName = "NID_brainpoolP160r1"; + +HcfEccCommParamsSpec *g_eccCommSpec = nullptr; + +HcfEccKeyPairParamsSpec g_brainpool160r1KeyPairSpec; + +void CryptoBrainPoolNoLengthVerifyTest::SetUp() {} +void CryptoBrainPoolNoLengthVerifyTest::TearDown() {} + +static const char *g_mockMessage = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 12 +}; + +static const char *GetMockClass(void) +{ + return "HcfSymKeyGenerator"; +} + +HcfObjectBase obj = { + .getClass = GetMockClass, + .destroy = nullptr +}; + +static HcfResult ConstructEccBrainPool160r1KeyPairCommParamsSpec(const string &algoName, HcfEccCommParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = nullptr; + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + *spec = eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult Constructbrainpool160r1KeyPairParamsSpec(const string &algoName, const string &curveName, + HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_brainpool160r1KeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = g_eccCommSpec->field; + eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccKeyPairSpec->base.a.data = g_eccCommSpec->a.data; + eccKeyPairSpec->base.a.len = g_eccCommSpec->a.len; + eccKeyPairSpec->base.b.data = g_eccCommSpec->b.data; + eccKeyPairSpec->base.b.len = g_eccCommSpec->b.len; + eccKeyPairSpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccKeyPairSpec->base.n.data = g_eccCommSpec->n.data; + eccKeyPairSpec->base.n.len = g_eccCommSpec->n.len; + eccKeyPairSpec->base.h = g_eccCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +void CryptoBrainPoolNoLengthVerifyTest::SetUpTestCase() +{ + ConstructEccBrainPool160r1KeyPairCommParamsSpec("NID_brainpoolP160r1", &g_eccCommSpec); +} + +void CryptoBrainPoolNoLengthVerifyTest::TearDownTestCase() +{ + FreeEccCommParamsSpec(g_eccCommSpec); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_1, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA1", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_2, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_3, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA256", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_4, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA384", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_5, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA512", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_6, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|MD5", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest002, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + const char *className = verify->base.getClass(); + ASSERT_NE(className, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest003, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + verify->base.destroy((HcfObjectBase *)verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest004, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + verify->base.destroy(nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest005, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + verify->base.destroy(&obj); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest006, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + const char *algName = verify->getAlgoName(verify); + ASSERT_NE(algName, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest007, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + const char *algName = verify->getAlgoName(nullptr); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest008, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + const char *algName = verify->getAlgoName((HcfVerify *)(&obj)); + ASSERT_EQ(algName, nullptr); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest009, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + HcfObjDestroy(generator); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest010, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(nullptr, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_SUCCESS); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest011, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init((HcfVerify *)(&obj), nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_SUCCESS); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest012, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest013, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest014, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, (HcfPubKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest015, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest016, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + + res = verify->update(nullptr, &g_mockInput); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest017, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + + res = verify->update((HcfVerify *)(&obj), &g_mockInput); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest018, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + + res = verify->update(verify, nullptr); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest019, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + HcfBlob input = { + .data = nullptr, + .len = 1 + }; + res = verify->update(verify, &input); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest020, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + + HcfBlob input = { + .data = (uint8_t *)g_mockMessage, + .len = 0 + }; + res = verify->update(verify, &input); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest021, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, nullptr, &out); + ASSERT_EQ(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest022, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + 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 = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + bool flag = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest023, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(nullptr, nullptr, &out); + ASSERT_NE(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest024, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify((HcfVerify *)&obj, nullptr, &out); + ASSERT_NE(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest025, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out); + ASSERT_NE(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(generator); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest026, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + 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); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob input = { + .data = nullptr, + .len = 1 + }; + + bool flag = verify->verify((HcfVerify *)(&obj), &input, &out); + ASSERT_NE(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(generator); +} + +HcfSignatureParams g_params = { + .algo = HCF_ALG_ECC, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, +}; + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest027, TestSize.Level0) +{ + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest028, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest029, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, (HcfPubKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest030, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest031, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest032, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest033, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest034, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest035, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest036, TestSize.Level0) +{ + HcfVerifySpi *spiObj = nullptr; + int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + HcfObjDestroy(spiObj); +} + +static bool GetSignTestData(HcfBlob *out, HcfPriKey *priKey) +{ + HcfSign *sign = nullptr; + + int32_t res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + if (res != HCF_SUCCESS) { + return false; + } + res = sign->init(sign, nullptr, 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, HcfPubKey *pubKey) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, nullptr, 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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest037, TestSize.Level0) +{ + StartRecordMallocNum(); + + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + HcfBlob out = { .data = nullptr, .len = 0 }; + GetSignTestData(&out, keyPair->priKey); + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetMallocNum(); + MemoryMockTestFunc(mallocCount, &out, keyPair->pubKey); + EndRecordMallocNum(); + HcfObjDestroy(generator); +} + +static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out, HcfPubKey *pubKey) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, nullptr, 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(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest038, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = Constructbrainpool160r1KeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1curveName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + ASSERT_EQ(GetSignTestData(&out, keyPair->priKey), true); + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount, &out, keyPair->pubKey); + EndRecordOpensslCallNum(); + HcfObjDestroy(generator); +} +} diff --git a/test/unittest/src/crypto_ecc_asy_key_generator_by_spec_test.cpp b/test/unittest/src/crypto_ecc_asy_key_generator_by_spec_test.cpp index 2244a2e..704fef8 100644 --- a/test/unittest/src/crypto_ecc_asy_key_generator_by_spec_test.cpp +++ b/test/unittest/src/crypto_ecc_asy_key_generator_by_spec_test.cpp @@ -686,6 +686,242 @@ static HcfResult ConstructEcc521KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec) return HCF_SUCCESS; } +static HcfResult ConstructEcc224ErrCommParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = &g_ecc224CommSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccCommSpec->base.algName = const_cast(g_eccAlgName.c_str()); + eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC; + eccCommSpec->field = tmpField; + eccCommSpec->field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP); + ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_secp224r1_len; + eccCommSpec->a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA); + eccCommSpec->a.len = NID_secp224r1_len; + eccCommSpec->b.data = nullptr; + eccCommSpec->b.len = 0; + eccCommSpec->g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX); + eccCommSpec->g.x.len = NID_secp224r1_len; + eccCommSpec->g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY); + eccCommSpec->g.y.len = NID_secp224r1_len; + eccCommSpec->n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN); + eccCommSpec->n.len = NID_secp224r1_len; + eccCommSpec->h = g_ecc224CorrectH; + + *spec = (HcfAsyKeyParamsSpec *)eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc256ErrCommParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = &g_ecc256CommSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccCommSpec->base.algName = const_cast(g_eccAlgName.c_str()); + eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC; + eccCommSpec->field = tmpField; + eccCommSpec->field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigP : g_ecc256CorrectLittleP); + ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_X9_62_prime256v1_len; + eccCommSpec->a.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigA : g_ecc256CorrectLittleA); + eccCommSpec->a.len = NID_X9_62_prime256v1_len; + eccCommSpec->b.data = 0; + eccCommSpec->b.len = 0; + eccCommSpec->g.x.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGX : g_ecc256CorrectLittleGX); + eccCommSpec->g.x.len = NID_X9_62_prime256v1_len; + eccCommSpec->g.y.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGY : g_ecc256CorrectLittleGY); + eccCommSpec->g.y.len = NID_X9_62_prime256v1_len; + eccCommSpec->n.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigN : g_ecc256CorrectLittleN); + eccCommSpec->n.len = NID_X9_62_prime256v1_len; + eccCommSpec->h = g_ecc256CorrectH; + + *spec = (HcfAsyKeyParamsSpec *)eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc384ErrCommParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = &g_ecc384CommSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccCommSpec->base.algName = const_cast(g_eccAlgName.c_str()); + eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC; + eccCommSpec->field = tmpField; + eccCommSpec->field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigP : g_ecc384CorrectLittleP); + ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_secp384r1_len; + eccCommSpec->a.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigA : g_ecc384CorrectLittleA); + eccCommSpec->a.len = NID_secp384r1_len; + eccCommSpec->b.data = nullptr; + eccCommSpec->b.len = 0; + eccCommSpec->g.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGX : g_ecc384CorrectLittleGX); + eccCommSpec->g.x.len = NID_secp384r1_len; + eccCommSpec->g.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGY : g_ecc384CorrectLittleGY); + eccCommSpec->g.y.len = NID_secp384r1_len; + eccCommSpec->n.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigN : g_ecc384CorrectLittleN); + eccCommSpec->n.len = NID_secp384r1_len; + eccCommSpec->h = g_ecc384CorrectH; + + *spec = (HcfAsyKeyParamsSpec *)eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc521ErrCommParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = &g_ecc521CommSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccCommSpec->base.algName = const_cast(g_eccAlgName.c_str()); + eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC; + eccCommSpec->field = tmpField; + eccCommSpec->field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccCommSpec->field))->p.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigP : g_ecc521CorrectLittleP); + ((HcfECFieldFp *)(eccCommSpec->field))->p.len = NID_secp521r1_len; + eccCommSpec->a.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigA : g_ecc521CorrectLittleA); + eccCommSpec->a.len = NID_secp521r1_len; + eccCommSpec->b.data = nullptr; + eccCommSpec->b.len = 0; + eccCommSpec->g.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGX : g_ecc521CorrectLittleGX); + eccCommSpec->g.x.len = NID_secp521r1_len; + eccCommSpec->g.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGY : g_ecc521CorrectLittleGY); + eccCommSpec->g.y.len = NID_secp521r1_len; + eccCommSpec->n.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigN : g_ecc521CorrectLittleN); + eccCommSpec->n.len = NID_secp521r1_len; + eccCommSpec->h = g_ecc521CorrectH; + + *spec = (HcfAsyKeyParamsSpec *)eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc384ErrKeyPairParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc384KeyPairSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccKeyPairSpec->base.base.algName = const_cast(g_eccAlgName.c_str()); + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = tmpField; + eccKeyPairSpec->base.field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = + (IS_BIG_ENDIAN ? g_ecc384CorrectBigP : g_ecc384CorrectLittleP); + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp384r1_len; + eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigA : g_ecc384CorrectLittleA); + eccKeyPairSpec->base.a.len = NID_secp384r1_len; + eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGX : g_ecc384CorrectLittleGX); + eccKeyPairSpec->base.g.x.len = NID_secp384r1_len; + eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGY : g_ecc384CorrectLittleGY); + eccKeyPairSpec->base.g.y.len = NID_secp384r1_len; + eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigN : g_ecc384CorrectLittleN); + eccKeyPairSpec->base.n.len = NID_secp384r1_len; + eccKeyPairSpec->base.h = g_ecc384CorrectH; + eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkX : g_ecc384CorrectLittlePkX); + eccKeyPairSpec->pk.x.len = NID_secp384r1_len; + eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkY : g_ecc384CorrectLittlePkY); + eccKeyPairSpec->pk.y.len = NID_secp384r1_len; + eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigSk : g_ecc384CorrectLittleSk); + eccKeyPairSpec->sk.len = NID_secp384r1_len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc521ErrKeyPairParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc521KeyPairSpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccKeyPairSpec->base.base.algName = const_cast(g_eccAlgName.c_str()); + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = tmpField; + eccKeyPairSpec->base.field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = + (IS_BIG_ENDIAN ? g_ecc521CorrectBigP : g_ecc521CorrectLittleP); + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp521r1_len; + eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigA : g_ecc521CorrectLittleA); + eccKeyPairSpec->base.a.len = NID_secp521r1_len; + eccKeyPairSpec->base.b.data = nullptr; + eccKeyPairSpec->base.b.len = 0; + eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGX : g_ecc521CorrectLittleGX); + eccKeyPairSpec->base.g.x.len = NID_secp521r1_len; + eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGY : g_ecc521CorrectLittleGY); + eccKeyPairSpec->base.g.y.len = NID_secp521r1_len; + eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigN : g_ecc521CorrectLittleN); + eccKeyPairSpec->base.n.len = NID_secp521r1_len; + eccKeyPairSpec->base.h = g_ecc521CorrectH; + eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkX : g_ecc521CorrectLittlePkX); + eccKeyPairSpec->pk.x.len = NID_secp521r1_len; + eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkY : g_ecc521CorrectLittlePkY); + eccKeyPairSpec->pk.y.len = NID_secp521r1_len; + eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigSk : g_ecc521CorrectLittleSk); + eccKeyPairSpec->sk.len = NID_secp521r1_len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc224ErrPubKeyParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccPubKeyParamsSpec *eccPubKeySpec = &g_ecc224PubKeySpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccPubKeySpec->base.base.algName = const_cast(g_eccAlgName.c_str()); + eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC; + eccPubKeySpec->base.field = tmpField; + eccPubKeySpec->base.field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.data = + (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP); + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.len = NID_secp224r1_len; + eccPubKeySpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA); + eccPubKeySpec->base.a.len = NID_secp224r1_len; + eccPubKeySpec->base.b.data = nullptr; + eccPubKeySpec->base.b.len = 0; + eccPubKeySpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX); + eccPubKeySpec->base.g.x.len = NID_secp224r1_len; + eccPubKeySpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY); + eccPubKeySpec->base.g.y.len = NID_secp224r1_len; + eccPubKeySpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN); + eccPubKeySpec->base.n.len = NID_secp224r1_len; + eccPubKeySpec->base.h = g_ecc224CorrectH; + eccPubKeySpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX); + eccPubKeySpec->pk.x.len = NID_secp224r1_len; + eccPubKeySpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY); + eccPubKeySpec->pk.y.len = NID_secp224r1_len; + + *spec = (HcfAsyKeyParamsSpec *)eccPubKeySpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructEcc224ErrPriKeyParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccPriKeyParamsSpec *eccPriKeySpec = &g_ecc224PriKeySpec; + HcfECField *tmpField = (HcfECField *)(&g_fieldFp); + + eccPriKeySpec->base.base.algName = const_cast(g_eccAlgName.c_str()); + eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC; + eccPriKeySpec->base.field = tmpField; + eccPriKeySpec->base.field->fieldType = const_cast(g_eccFieldType.c_str()); + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.data = + (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP); + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.len = NID_secp224r1_len; + eccPriKeySpec->base.a.data = nullptr; + eccPriKeySpec->base.a.len = 0; + eccPriKeySpec->base.b.data = nullptr; + eccPriKeySpec->base.b.len = 0; + eccPriKeySpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX); + eccPriKeySpec->base.g.x.len = NID_secp224r1_len; + eccPriKeySpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY); + eccPriKeySpec->base.g.y.len = NID_secp224r1_len; + eccPriKeySpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN); + eccPriKeySpec->base.n.len = NID_secp224r1_len; + eccPriKeySpec->base.h = g_ecc224CorrectH; + eccPriKeySpec->sk.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk); + eccPriKeySpec->sk.len = NID_secp224r1_len; + + *spec = (HcfAsyKeyParamsSpec *)eccPriKeySpec; + return HCF_SUCCESS; +} + /** * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoEccAsyKeyGeneratorBySpecTest001 * @tc.desc: Verify that the creation of the ECC224 key pair generator is normal. @@ -8135,4 +8371,212 @@ HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest6 HcfObjDestroy(generator); HcfObjDestroy(generatorSpec); } + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest610, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_224, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc224ErrCommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest611, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_521, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc521ErrKeyPairParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest612, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_224, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc224ErrPubKeyParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfPubKey *keyPair = nullptr; + res = spiObj->engineGeneratePubKeyBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest613, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_224, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc224ErrPriKeyParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfPriKey *keyPair = nullptr; + res = spiObj->engineGeneratePriKeyBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest614, 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); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc256ErrCommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest615, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_384, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc384ErrCommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest616, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_521, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc521ErrCommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorBySpecTest, CryptoEccAsyKeyGeneratorBySpecTest617, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_521, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructEcc384ErrKeyPairParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} } diff --git a/test/unittest/src/crypto_ecc_key_util_test.cpp b/test/unittest/src/crypto_ecc_key_util_test.cpp new file mode 100644 index 0000000..9bd5673 --- /dev/null +++ b/test/unittest/src/crypto_ecc_key_util_test.cpp @@ -0,0 +1,1947 @@ +/* + * 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 +#include + +#include "asy_key_generator.h" +#include "blob.h" +#include "detailed_ecc_key_params.h" +#include "ecc_key_util.h" +#include "ecc_openssl_common.h" +#include "ecc_common.h" +#include "ecdsa_openssl.h" +#include "memory.h" +#include "securec.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "openssl_common.h" +#include "asy_key_params.h" +#include "log.h" +#include "params_parser.h" +#include "ecc_common_param_spec_generator_openssl.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoEccKeyUtilTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1"; +static string g_brainpool160t1AlgName = "ECC_BrainPoolP160t1"; +static string g_brainpool192r1AlgName = "ECC_BrainPoolP192r1"; +static string g_brainpool192t1AlgName = "ECC_BrainPoolP192t1"; +static string g_brainpool224r1AlgName = "ECC_BrainPoolP224r1"; +static string g_brainpool224t1AlgName = "ECC_BrainPoolP224t1"; +static string g_brainpool256r1AlgName = "ECC_BrainPoolP256r1"; +static string g_brainpool256t1AlgName = "ECC_BrainPoolP256t1"; +static string g_brainpool320r1AlgName = "ECC_BrainPoolP320r1"; +static string g_brainpool320t1AlgName = "ECC_BrainPoolP320t1"; +static string g_brainpool384r1AlgName = "ECC_BrainPoolP384r1"; +static string g_brainpool384t1AlgName = "ECC_BrainPoolP384t1"; +static string g_brainpool512r1AlgName = "ECC_BrainPoolP512r1"; +static string g_brainpool512t1AlgName = "ECC_BrainPoolP512t1"; + +HcfEccCommParamsSpec *g_brainpool160r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool160t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool192r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool192t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool224r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool224t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool256r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool256t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool320r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool320t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool384r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool384t1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool512r1CommSpec = nullptr; +HcfEccCommParamsSpec *g_brainpool512t1CommSpec = nullptr; + +HcfEccKeyPairParamsSpec g_brainpoolKeyPairSpec; +HcfEccPriKeyParamsSpec g_brainpool160r1PriKeySpec; +HcfEccPubKeyParamsSpec g_brainpool160r1PubKeySpec; + +void CryptoEccKeyUtilTest::SetUp() {} +void CryptoEccKeyUtilTest::TearDown() {} + +static const char *g_mockMessage = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 12 +}; + +static const char *GetMockClass(void) +{ + return "HcfEcc"; +} + +HcfObjectBase g_obj = { + .getClass = GetMockClass, + .destroy = nullptr}; + + +static HcfResult ConstructEccBrainPoolKeyPairCommParamsSpec(const string &algoName, HcfEccCommParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = nullptr; + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + + *spec = eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructbrainpoolKeyPairParamsSpec(const string &algoName, + HcfEccCommParamsSpec *brainpoolCommSpec, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_brainpoolKeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = brainpoolCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = brainpoolCommSpec->field; + eccKeyPairSpec->base.field->fieldType = brainpoolCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.len; + eccKeyPairSpec->base.a.data = brainpoolCommSpec->a.data; + eccKeyPairSpec->base.a.len = brainpoolCommSpec->a.len; + eccKeyPairSpec->base.b.data = brainpoolCommSpec->b.data; + eccKeyPairSpec->base.b.len = brainpoolCommSpec->b.len; + eccKeyPairSpec->base.g.x.data = brainpoolCommSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = brainpoolCommSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = brainpoolCommSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = brainpoolCommSpec->g.y.len; + eccKeyPairSpec->base.n.data = brainpoolCommSpec->n.data; + eccKeyPairSpec->base.n.len = brainpoolCommSpec->n.len; + eccKeyPairSpec->base.h = brainpoolCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +static HcfResult Constructbrainpool160r1PubKeyParamsSpec(const string &algoName, + HcfEccCommParamsSpec *brainpoolCommSpec, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPubKeyParamsSpec *eccPubKeySpec = &g_brainpool160r1PubKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPubKeySpec->base.base.algName = brainpoolCommSpec->base.algName; + eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC; + eccPubKeySpec->base.field = brainpoolCommSpec->field; + eccPubKeySpec->base.field->fieldType = brainpoolCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.data = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.len = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.len; + eccPubKeySpec->base.a.data = brainpoolCommSpec->a.data; + eccPubKeySpec->base.a.len = brainpoolCommSpec->a.len; + eccPubKeySpec->base.b.data = brainpoolCommSpec->b.data; + eccPubKeySpec->base.b.len = brainpoolCommSpec->b.len; + eccPubKeySpec->base.g.x.data = brainpoolCommSpec->g.x.data; + eccPubKeySpec->base.g.x.len = brainpoolCommSpec->g.x.len; + eccPubKeySpec->base.g.y.data = brainpoolCommSpec->g.y.data; + eccPubKeySpec->base.g.y.len = brainpoolCommSpec->g.y.len; + eccPubKeySpec->base.n.data = brainpoolCommSpec->n.data; + eccPubKeySpec->base.n.len = brainpoolCommSpec->n.len; + eccPubKeySpec->base.h = brainpoolCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccPubKeySpec->pk.x.data = retBigInt.data; + eccPubKeySpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccPubKeySpec->pk.y.data =retBigInt.data; + eccPubKeySpec->pk.y.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccPubKeySpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +static HcfResult Constructbrainpool160r1PriKeyParamsSpec(const string &algoName, + HcfEccCommParamsSpec *brainpoolCommSpec, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPriKeyParamsSpec *eccPriKeySpec = &g_brainpool160r1PriKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPriKeySpec->base.base.algName = brainpoolCommSpec->base.algName; + eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC; + eccPriKeySpec->base.field = brainpoolCommSpec->field; + eccPriKeySpec->base.field->fieldType = brainpoolCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.data = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.len = ((HcfECFieldFp *)(brainpoolCommSpec->field))->p.len; + eccPriKeySpec->base.a.data = brainpoolCommSpec->a.data; + eccPriKeySpec->base.a.len = brainpoolCommSpec->a.len; + eccPriKeySpec->base.b.data = brainpoolCommSpec->b.data; + eccPriKeySpec->base.b.len = brainpoolCommSpec->b.len; + eccPriKeySpec->base.g.x.data = brainpoolCommSpec->g.x.data; + eccPriKeySpec->base.g.x.len = brainpoolCommSpec->g.x.len; + eccPriKeySpec->base.g.y.data = brainpoolCommSpec->g.y.data; + eccPriKeySpec->base.g.y.len = brainpoolCommSpec->g.y.len; + eccPriKeySpec->base.n.data = brainpoolCommSpec->n.data; + eccPriKeySpec->base.n.len = brainpoolCommSpec->n.len; + eccPriKeySpec->base.h = brainpoolCommSpec->h; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccPriKeySpec->sk.data = retBigInt.data; + eccPriKeySpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccPriKeySpec; + HcfObjDestroy(generator); + + return HCF_SUCCESS; +} + +void CryptoEccKeyUtilTest::SetUpTestCase() +{ + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP160t1", &g_brainpool160t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP192r1", &g_brainpool192r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP192t1", &g_brainpool192t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP224r1", &g_brainpool224r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP224t1", &g_brainpool224t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP256r1", &g_brainpool256r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP256t1", &g_brainpool256t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP320r1", &g_brainpool320r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP320t1", &g_brainpool320t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP384r1", &g_brainpool384r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP384t1", &g_brainpool384t1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP512r1", &g_brainpool512r1CommSpec); + ConstructEccBrainPoolKeyPairCommParamsSpec("NID_brainpoolP512t1", &g_brainpool512t1CommSpec); +} + +void CryptoEccKeyUtilTest::TearDownTestCase() +{ + FreeEccCommParamsSpec(g_brainpool160r1CommSpec); + FreeEccCommParamsSpec(g_brainpool160t1CommSpec); + FreeEccCommParamsSpec(g_brainpool192r1CommSpec); + FreeEccCommParamsSpec(g_brainpool192t1CommSpec); + FreeEccCommParamsSpec(g_brainpool224r1CommSpec); + FreeEccCommParamsSpec(g_brainpool224t1CommSpec); + FreeEccCommParamsSpec(g_brainpool256r1CommSpec); + FreeEccCommParamsSpec(g_brainpool256t1CommSpec); + FreeEccCommParamsSpec(g_brainpool320r1CommSpec); + FreeEccCommParamsSpec(g_brainpool320t1CommSpec); + FreeEccCommParamsSpec(g_brainpool384r1CommSpec); + FreeEccCommParamsSpec(g_brainpool384t1CommSpec); + FreeEccCommParamsSpec(g_brainpool512r1CommSpec); + FreeEccCommParamsSpec(g_brainpool512t1CommSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_1, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_2, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP160t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_3, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP192r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_4, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP192t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_5, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP224r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_6, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP224t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_7, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP256r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_8, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP256t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_9, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP320r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_10, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP320t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_11, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP384r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_12, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP384t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_13, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP512r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_14, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_brainpoolP512t1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_15, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_secp224r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_16, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_X9_62_prime256v1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_17, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_secp384r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_18, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_secp521r1", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_19, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("NID_sm2", &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest002, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate(nullptr, &returnCommonParamSpec); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest003, TestSize.Level0) +{ + int32_t res = HcfEccKeyUtilCreate("ECC_BrainPoolP160r1", nullptr); + ASSERT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest004, TestSize.Level0) +{ + HcfEccCommParamsSpec *returnCommonParamSpec; + int32_t res = HcfEccKeyUtilCreate("BrainPoolP999", &returnCommonParamSpec); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(returnCommonParamSpec, nullptr); + + FreeEccCommParamsSpec(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest005, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + const char *classname = returnObj->base.getClass(); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(classname, nullptr); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest006, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + returnObj->base.destroy(&g_obj); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest007, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + const char *algName = returnObj->getAlgName(returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest008, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest009, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char *classname = returnKeyPair->base.getClass(); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(classname, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest010, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + + returnKeyPair->base.destroy(&(returnKeyPair->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest011, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->base.destroy(nullptr); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest012, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->base.destroy(&g_obj); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest013, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char *classname = returnKeyPair->pubKey->base.base.getClass(); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(classname, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest014, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->pubKey->base.base.destroy(&(returnKeyPair->pubKey->base.base)); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest015, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->pubKey->base.base.destroy(nullptr); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest016, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->pubKey->base.base.destroy(&g_obj); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest017, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char * format = returnKeyPair->pubKey->base.getFormat(&(returnKeyPair->pubKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(format, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest018, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char * algorithm = returnKeyPair->pubKey->base.getAlgorithm(&(returnKeyPair->pubKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(algorithm, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest019, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + res = returnKeyPair->pubKey->base.getEncoded(&(returnKeyPair->pubKey->base), &pubKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest020, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + returnKeyPair->priKey->clearMem(returnKeyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest021, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + returnKeyPair->priKey->clearMem(nullptr); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest022, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + returnKeyPair->priKey->clearMem((HcfPriKey *)&g_obj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest023, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char *classname = returnKeyPair->priKey->base.base.getClass(); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(classname, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest024, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->priKey->base.base.destroy(&(returnKeyPair->priKey->base.base)); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest025, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->priKey->base.base.destroy(nullptr); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest026, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + returnKeyPair->priKey->base.base.destroy(&g_obj); + + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest027, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char *format = returnKeyPair->priKey->base.getFormat(&(returnKeyPair->priKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(format, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest028, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + const char *algorithm = returnKeyPair->priKey->base.getAlgorithm(&(returnKeyPair->priKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + ASSERT_NE(algorithm, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest029, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; + res = returnKeyPair->priKey->base.getEncoded(&(returnKeyPair->priKey->base), &priKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest030, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + ASSERT_NE(res, HCF_INVALID_PARAMS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + + HcfObjDestroy(returnPubKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest031, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + + returnPubKey->base.base.destroy(&(returnPubKey->base.base)); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest032, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + const char *format = returnPubKey->base.getFormat(&(returnPubKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + ASSERT_NE(format, nullptr); + + HcfObjDestroy(returnPubKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest033, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + const char *algorithm = returnPubKey->base.getAlgorithm(&(returnPubKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + ASSERT_NE(algorithm, nullptr); + + HcfObjDestroy(returnPubKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest034, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = returnPubKey->base.getEncoded(&(returnPubKey->base), &blob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + + HcfObjDestroy(returnPubKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest035, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest036, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + + returnPriKey->base.base.destroy(&(returnPriKey->base.base)); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest037, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + returnPriKey->clearMem(returnPriKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest038, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + const char *algorithm = returnPriKey->base.getAlgorithm(&(returnPriKey->base)); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + ASSERT_NE(algorithm, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_1, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, returnKeyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_2, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160t1AlgName, g_brainpool160t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP160t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP160t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_3, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool192r1AlgName, g_brainpool192r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP192r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP192r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_4, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool192t1AlgName, g_brainpool192t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP192t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP192t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_5, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool224r1AlgName, g_brainpool224r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP224r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP224r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_6, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool224t1AlgName, g_brainpool224t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP224t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP224t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_7, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool256r1AlgName, g_brainpool256r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP256r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP256r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_8, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool256t1AlgName, g_brainpool256t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP256t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP256t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_9, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool320r1AlgName, g_brainpool320r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP320r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP320r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_10, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool320t1AlgName, g_brainpool320t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP320t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP320t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_11, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool384r1AlgName, g_brainpool384r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP384r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP384r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_12, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool384t1AlgName, g_brainpool384t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP384t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP384t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_13, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool512r1AlgName, g_brainpool512r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP512r1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP512r1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_14, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool512t1AlgName, g_brainpool512t1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_BrainPoolP512t1|SHA224", &sign); + res = sign->init(sign, nullptr, returnKeyPair->priKey); + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, &g_mockInput, &out); + HcfVerify *verify; + res = HcfVerifyCreate("ECC_BrainPoolP512t1|SHA224", &verify); + res = verify->init(verify, nullptr, returnKeyPair->pubKey); + res = verify->verify(verify, &g_mockInput, &out); + ASSERT_EQ(res, true); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest040, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnKeyPair; + res = returnObj->generateKeyPair(returnObj, &returnKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnKeyPair, nullptr); + + HcfObjDestroy(returnKeyPair); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest041, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PubKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPubKey; + res = returnObj->generatePubKey(returnObj, &returnPubKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPubKey, nullptr); + + HcfObjDestroy(returnPubKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest042, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest043, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfKeyPair *returnPriKey; + res = returnObj->generateKeyPair(returnObj, &returnPriKey); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_EQ(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest044, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructbrainpoolKeyPairParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPriKey *returnPriKey; + res = returnObj->generatePriKey(returnObj, &returnPriKey); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_NE(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest045, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = Constructbrainpool160r1PriKeyParamsSpec(g_brainpool160r1AlgName, g_brainpool160r1CommSpec, + ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *returnObj = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + + HcfPubKey *returnPriKey; + res = returnObj->generatePubKey(returnObj, &returnPriKey); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_NE(returnObj, nullptr); + ASSERT_EQ(returnPriKey, nullptr); + + HcfObjDestroy(returnPriKey); + HcfObjDestroy(returnObj); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest046, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_BP160R1, + .primes = HCF_OPENSSL_PRIMES_2 + }; + HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr; + int32_t res = HcfECCCommonParamSpecCreate(¶ms, &returnCommonParamSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(returnCommonParamSpec, nullptr); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest047, TestSize.Level0) +{ + HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr; + int32_t res = HcfECCCommonParamSpecCreate(nullptr, &returnCommonParamSpec); + ASSERT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest048, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_BP160R1, + .primes = HCF_OPENSSL_PRIMES_2 + }; + int32_t res = HcfECCCommonParamSpecCreate(¶ms, nullptr); + ASSERT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest049, TestSize.Level0) +{ + HcfAsyKeyGenParams obj = { + .algo = HCF_ALG_ECC, + .bits = HCF_OPENSSL_RSA_2048, + .primes = HCF_OPENSSL_PRIMES_2 + }; + HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr; + int32_t res = HcfECCCommonParamSpecCreate(&obj, &returnCommonParamSpec); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(returnCommonParamSpec, nullptr); + + HcfObjDestroy(returnCommonParamSpec); +} + +HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest050, TestSize.Level0) +{ + HcfAsyKeyGenParams obj = { + .algo = HCF_ALG_ECC, + .bits = 0, + .primes = HCF_OPENSSL_PRIMES_2 + }; + HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr; + int32_t res = HcfECCCommonParamSpecCreate(&obj, &returnCommonParamSpec); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(returnCommonParamSpec, nullptr); + + HcfObjDestroy(returnCommonParamSpec); +} +} \ No newline at end of file diff --git a/test/unittest/src/crypto_sm2_asy_key_generator_by_spec_test.cpp b/test/unittest/src/crypto_sm2_asy_key_generator_by_spec_test.cpp new file mode 100644 index 0000000..1f02f77 --- /dev/null +++ b/test/unittest/src/crypto_sm2_asy_key_generator_by_spec_test.cpp @@ -0,0 +1,3097 @@ +/* + * 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 +#include +#include "securec.h" + +#include "asy_key_generator.h" +#include "sm2_asy_key_generator_openssl.h" +#include "detailed_ecc_key_params.h" +#include "ecc_openssl_common.h" +#include "ecc_common.h" +#include "ecc_key_util.h" +#include "key_utils.h" +#include "blob.h" +#include "cipher.h" +#include "cipher_sm2_openssl.h" +#include "sm2_openssl.h" +#include "signature.h" +#include "key_pair.h" +#include "memory.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "openssl_class.h" +#include "openssl_common.h" +#include "params_parser.h" + +using namespace std; +using namespace testing::ext; + +namespace { +constexpr int ZERO = 0; +constexpr int ONE = 1; +constexpr int TWO = 2; +constexpr int THREE = 3; +constexpr int FOUR = 4; +constexpr int FIVE = 5; +constexpr int SIX = 6; +constexpr int SEVEN = 7; +constexpr int EIGHT = 8; + +class CryptoSm2AsyKeyGeneratorBySpecTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void CryptoSm2AsyKeyGeneratorBySpecTest::SetUp() {} +void CryptoSm2AsyKeyGeneratorBySpecTest::TearDown() {} + +static const char *GetMockClass(void) +{ + return "HcfSymKeyGenerator"; +} + +HcfObjectBase g_obj = { + .getClass = GetMockClass, + .destroy = nullptr +}; + +static const char *g_mockMessage = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)g_mockMessage, + .len = 12 +}; + +static string g_sm2AlgName = "SM2_256"; +static string g_sm2CurveName = "NID_sm2"; + +HcfEccPubKeyParamsSpec g_sm2256PubKeySpec; +HcfEccPriKeyParamsSpec g_sm2256PriKeySpec; +HcfEccKeyPairParamsSpec g_sm2256KeyPairSpec; +HcfEccCommParamsSpec g_sm2256CommSpec; +HcfEccCommParamsSpec *g_eccCommSpec = nullptr; + +static HcfResult ConstructSm2256CommParamsSpec(HcfAsyKeyParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = &g_sm2256CommSpec; + HcfEccKeyUtilCreate(g_sm2CurveName.c_str(), &eccCommSpec); + + *spec = (HcfAsyKeyParamsSpec *)eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructSm2256KeyPairCommParamsSpec(const string &algoName, HcfEccCommParamsSpec **spec) +{ + HcfEccCommParamsSpec *eccCommSpec = nullptr; + + HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec); + + *spec = eccCommSpec; + return HCF_SUCCESS; +} + +static HcfResult ConstructSm2256KeyPairParamsSpec(const string &algoName, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_sm2256KeyPairSpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = g_eccCommSpec->field; + eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccKeyPairSpec->base.a.data = g_eccCommSpec->a.data; + eccKeyPairSpec->base.a.len = g_eccCommSpec->a.len; + eccKeyPairSpec->base.b.data = g_eccCommSpec->b.data; + eccKeyPairSpec->base.b.len = g_eccCommSpec->b.len; + eccKeyPairSpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccKeyPairSpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccKeyPairSpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccKeyPairSpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccKeyPairSpec->base.n.data = g_eccCommSpec->n.data; + eccKeyPairSpec->base.n.len = g_eccCommSpec->n.len; + eccKeyPairSpec->base.h = g_eccCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccKeyPairSpec->pk.x.data = retBigInt.data; + eccKeyPairSpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccKeyPairSpec->pk.y.data =retBigInt.data; + eccKeyPairSpec->pk.y.len = retBigInt.len; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccKeyPairSpec->sk.data = retBigInt.data; + eccKeyPairSpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +static HcfResult ConstructSm2256PriKeyParamsSpec(const string &algoName, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPriKeyParamsSpec *eccPriKeySpec = &g_sm2256PriKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPriKeySpec->base.base.algName = g_eccCommSpec->base.algName; + eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC; + eccPriKeySpec->base.field = g_eccCommSpec->field; + eccPriKeySpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccPriKeySpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccPriKeySpec->base.a.data = g_eccCommSpec->a.data; + eccPriKeySpec->base.a.len = g_eccCommSpec->a.len; + eccPriKeySpec->base.b.data = g_eccCommSpec->b.data; + eccPriKeySpec->base.b.len = g_eccCommSpec->b.len; + eccPriKeySpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccPriKeySpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccPriKeySpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccPriKeySpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccPriKeySpec->base.n.data = g_eccCommSpec->n.data; + eccPriKeySpec->base.n.len = g_eccCommSpec->n.len; + eccPriKeySpec->base.h = g_eccCommSpec->h; + + res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt); + eccPriKeySpec->sk.data = retBigInt.data; + eccPriKeySpec->sk.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccPriKeySpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +static HcfResult ConstructSm2256PubKeyParamsSpec(const string &algoName, HcfAsyKeyParamsSpec **spec) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + HcfEccPubKeyParamsSpec *eccPubKeySpec = &g_sm2256PubKeySpec; + HcfBigInteger retBigInt = { .data = nullptr, .len = 0 }; + + eccPubKeySpec->base.base.algName = g_eccCommSpec->base.algName; + eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC; + eccPubKeySpec->base.field = g_eccCommSpec->field; + eccPubKeySpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.data = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.data; + ((HcfECFieldFp *)(eccPubKeySpec->base.field))->p.len = ((HcfECFieldFp *)(g_eccCommSpec->field))->p.len; + eccPubKeySpec->base.a.data = g_eccCommSpec->a.data; + eccPubKeySpec->base.a.len = g_eccCommSpec->a.len; + eccPubKeySpec->base.b.data = g_eccCommSpec->b.data; + eccPubKeySpec->base.b.len = g_eccCommSpec->b.len; + eccPubKeySpec->base.g.x.data = g_eccCommSpec->g.x.data; + eccPubKeySpec->base.g.x.len = g_eccCommSpec->g.x.len; + eccPubKeySpec->base.g.y.data = g_eccCommSpec->g.y.data; + eccPubKeySpec->base.g.y.len = g_eccCommSpec->g.y.len; + eccPubKeySpec->base.n.data = g_eccCommSpec->n.data; + eccPubKeySpec->base.n.len = g_eccCommSpec->n.len; + eccPubKeySpec->base.h = g_eccCommSpec->h; + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt); + eccPubKeySpec->pk.x.data = retBigInt.data; + eccPubKeySpec->pk.x.len = retBigInt.len; + + res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt); + eccPubKeySpec->pk.y.data =retBigInt.data; + eccPubKeySpec->pk.y.len = retBigInt.len; + + *spec = (HcfAsyKeyParamsSpec *)eccPubKeySpec; + HcfObjDestroy(generator); + return HCF_SUCCESS; +} + +void CryptoSm2AsyKeyGeneratorBySpecTest::SetUpTestCase() +{ + ConstructSm2256KeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec); +} + +void CryptoSm2AsyKeyGeneratorBySpecTest::TearDownTestCase() +{ + FreeEccCommParamsSpec(g_eccCommSpec); +} + +/** + * @tc.name: CryptoEccAsyKeyGeneratorBySpecTest.CryptoSm2AsyKeyGeneratorBySpecTest001 + * @tc.desc: Verify that the creation of the sm2 key pair generator is normal. + * @tc.type: FUNC + * @tc.require: I5QWEI + */ +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest001, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest002, TestSize.Level0) +{ + HcfAsyKeyGeneratorBySpec *generator = nullptr; + + int32_t res = HcfAsyKeyGeneratorBySpecCreate(nullptr, &generator); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(generator, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest003, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest004, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *className = generator->base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest005, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + generator->base.destroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest006, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + generator->base.destroy(nullptr); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest007, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + generator->base.destroy(&g_obj); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest008, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgName(generator); + + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest009, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgName(nullptr); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest010, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + const char *algName = generator->getAlgName((HcfAsyKeyGeneratorBySpec *)&g_obj); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest011, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(keyPair, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest012, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(nullptr, &keyPair); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(keyPair, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest013, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generateKeyPair(generator, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest014, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generateKeyPair(nullptr, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest015, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest016, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest017, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy(nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest018, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->base.destroy(&g_obj); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest019, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->pubKey->base.base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest020, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base))); + keyPair->pubKey = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest021, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy(nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest022, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->pubKey->base.base.destroy(&g_obj); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest023, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base)); + + ASSERT_NE(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest024, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat(nullptr); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest025, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest026, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base)); + + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest027, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest028, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest029, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest030, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest031, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest032, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest033, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(keyPair->priKey); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest034, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->clearMem(nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest035, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest036, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *className = keyPair->priKey->base.base.getClass(); + ASSERT_NE(className, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest037, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base))); + keyPair->priKey = nullptr; + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest038, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest039, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + keyPair->priKey->base.base.destroy(&g_obj); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest040, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat(&(keyPair->priKey->base)); + + ASSERT_NE(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest041, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat(nullptr); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest042, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest043, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base)); + + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest044, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.getAlgorithm(nullptr); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest045, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest046, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest047, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest048, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest049, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest050, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest051, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(nullptr, &pubKey); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(pubKey, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest052, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generatePubKey(generator, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest053, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generatePubKey(nullptr, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest054, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *className = pubKey->base.base.getClass(); + + ASSERT_NE(className, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest055, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + pubKey->base.base.destroy((HcfObjectBase *)(&(pubKey->base.base))); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest056, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + pubKey->base.base.destroy(nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest057, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + pubKey->base.base.destroy(&g_obj); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest058, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *format = pubKey->base.getFormat(&(pubKey->base)); + + ASSERT_NE(format, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest059, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *format = pubKey->base.getFormat(nullptr); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest060, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *format = pubKey->base.getFormat((HcfKey *)&g_obj); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest061, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *algName = pubKey->base.getAlgorithm(&(pubKey->base)); + + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest062, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *algName = pubKey->base.getAlgorithm(nullptr); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest063, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + const char *algName = pubKey->base.getAlgorithm((HcfKey *)&g_obj); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest064, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = pubKey->base.getEncoded(&(pubKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest065, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = pubKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest066, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + HcfBlob blob = { .data = nullptr, .len = 0 }; + res = pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest067, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PubKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + res = pubKey->base.getEncoded(&(pubKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest068, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest069, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(nullptr, &priKey); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(priKey, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest070, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generatePriKey(generator, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest071, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->generatePriKey(nullptr, nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest072, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *className = priKey->base.base.getClass(); + + ASSERT_NE(className, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest073, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + priKey->base.base.destroy((HcfObjectBase *)(&(priKey->base.base))); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest074, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + priKey->base.base.destroy(nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest075, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + priKey->base.base.destroy(&g_obj); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest076, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + res = priKey->base.getEncoded(&(priKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest077, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + priKey->clearMem(priKey); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest078, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + priKey->clearMem(nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest079, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *format = priKey->base.getFormat(&priKey->base); + + ASSERT_NE(format, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest080, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *format = priKey->base.getFormat(nullptr); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest081, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *format = priKey->base.getFormat((HcfKey *)&g_obj); + + ASSERT_EQ(format, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest082, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *algName = priKey->base.getAlgorithm(&priKey->base); + + ASSERT_NE(algName, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest083, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *algName = priKey->base.getAlgorithm(nullptr); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest084, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + const char *algName = priKey->base.getAlgorithm((HcfKey *)&g_obj); + + ASSERT_EQ(algName, nullptr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest085, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + HcfBlob blob = {.data = nullptr, .len = 0}; + res = priKey->base.getEncoded(&(priKey->base), &blob); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(blob.data, nullptr); + ASSERT_NE(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest086, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + HcfBlob blob = {.data = nullptr, .len = 0}; + res = priKey->base.getEncoded(nullptr, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest087, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + HcfBlob blob = {.data = nullptr, .len = 0}; + res = priKey->base.getEncoded((HcfKey *)&g_obj, &blob); + + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(blob.data, nullptr); + ASSERT_EQ(blob.len, 0); + + free(blob.data); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest088, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256PriKeyParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + res = priKey->base.getEncoded(&(priKey->base), nullptr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest089, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + + HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generatorBySpec, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = {.data = nullptr, .len = 0}; + HcfBlob priKeyBlob = {.data = nullptr, .len = 0}; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outKeyPair, nullptr); + HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPubKeyBlob.data, nullptr); + ASSERT_NE(outPubKeyBlob.len, 0); + HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPriKeyBlob.data, nullptr); + ASSERT_NE(outPriKeyBlob.len, 0); + free(pubKeyBlob.data); + free(priKeyBlob.data); + free(outPubKeyBlob.data); + free(outPriKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(generator); + HcfObjDestroy(generatorBySpec); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest090, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + uint8_t plan[] = "this is sm2 cipher test!\0"; + HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)}; + HcfBlob encoutput = {.data = nullptr, .len = 0}; + HcfCipher *cipher = nullptr; + res = HcfCipherCreate("SM2|SM3", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + + 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); + HcfObjDestroy(cipher); + + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; + res = HcfCipherCreate("SM2|SM3", &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + 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); + HcfObjDestroy(cipher); + EXPECT_STREQ((char *)plan, (char *)decoutput.data); + + HcfFree(encoutput.data); + HcfFree(decoutput.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest091, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(paramSpec, nullptr); + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfSign *sign = nullptr; + res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + 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 = nullptr; + res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, keyPair->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest092, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_SM2, + .bits = HCF_ALG_SM2_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiSm2Create(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest093, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_SM2, + .bits = HCF_ALG_SM2_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiSm2Create(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfPubKey *pubKey = nullptr; + res = spiObj->engineGeneratePubKeyBySpec(spiObj, paramSpec, &pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest094, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_SM2, + .bits = HCF_ALG_SM2_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiSm2Create(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfPriKey *priKey = nullptr; + res = spiObj->engineGeneratePriKeyBySpec(spiObj, paramSpec, &priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest095, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_SM2, + .bits = 0, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiSm2Create(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfAsyKeyParamsSpec *paramSpec = nullptr; + res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest096, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfPriKey *priKey = nullptr; + res = generator->generatePriKey(generator, &priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(priKey, nullptr); + + char *retStr = nullptr; + AsyKeySpecItem item = ECC_CURVE_NAME_STR; + + res = priKey->getAsyKeySpecString(priKey, item, &retStr); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(retStr, nullptr); + + free(retStr); + + HcfObjDestroy(priKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest097, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfPubKey *pubKey = nullptr; + res = generator->generatePubKey(generator, &pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(pubKey, nullptr); + + AsyKeySpecItem item = ECC_CURVE_NAME_STR; + + res = pubKey->getAsyKeySpecString(pubKey, item, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(pubKey); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest098, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + char *retStr = nullptr; + AsyKeySpecItem item = ECC_FIELD_TYPE_STR; + + res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, item, &retStr); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(retStr, nullptr); + + free(retStr); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest099, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256CommParamsSpec(¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + AsyKeySpecItem item = ECC_FIELD_TYPE_STR; + + res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, item, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest100, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + int retInt = 0; + AsyKeySpecItem item = ECC_FIELD_SIZE_INT; + + res = keyPair->pubKey->getAsyKeySpecInt(keyPair->pubKey, item, &retInt); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(retInt, 0); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest101, TestSize.Level0) +{ + HcfAsyKeyParamsSpec *paramSpec = nullptr; + int32_t res = ConstructSm2256KeyPairParamsSpec(g_sm2AlgName, ¶mSpec); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfAsyKeyGeneratorBySpec *generator = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + AsyKeySpecItem item = ECC_FIELD_SIZE_INT; + + res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, item, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +static HcfResult ConstructSm2256KeyPairParamsSpecByGet(HcfEccKeyPairParamsSpec *eccKeyPairSpec, + HcfBigInteger *params, int h) +{ + eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName; + eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC; + eccKeyPairSpec->base.field = g_eccCommSpec->field; + eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = params[ZERO].data; + ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = params[ZERO].len; + eccKeyPairSpec->base.a.data = params[ONE].data; + eccKeyPairSpec->base.a.len = params[ONE].len; + eccKeyPairSpec->base.b.data = params[TWO].data; + eccKeyPairSpec->base.b.len = params[TWO].len; + eccKeyPairSpec->base.g.x.data = params[THREE].data; + eccKeyPairSpec->base.g.x.len = params[THREE].len; + eccKeyPairSpec->base.g.y.data = params[FOUR].data; + eccKeyPairSpec->base.g.y.len = params[FOUR].len; + + eccKeyPairSpec->base.n.data = params[FIVE].data; + eccKeyPairSpec->base.n.len = params[FIVE].len; + eccKeyPairSpec->base.h = h; + eccKeyPairSpec->pk.x.data = params[SIX].data; + eccKeyPairSpec->pk.x.len = params[SIX].len; + eccKeyPairSpec->pk.y.data = params[SEVEN].data; + eccKeyPairSpec->pk.y.len = params[SEVEN].len; + + eccKeyPairSpec->sk.data = params[EIGHT].data; + eccKeyPairSpec->sk.len = params[EIGHT].len; + return HCF_SUCCESS; +} + +HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest102, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate(g_sm2AlgName.c_str(), &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(keyPair, nullptr); + HcfPriKey *priKey = keyPair->priKey; + HcfPubKey *pubKey = keyPair->pubKey; + HcfBigInteger retFp = { .data = nullptr, .len = 0 }; + HcfBigInteger retA = { .data = nullptr, .len = 0 }; + HcfBigInteger retB = { .data = nullptr, .len = 0 }; + HcfBigInteger retGX = { .data = nullptr, .len = 0 }; + HcfBigInteger retGY = { .data = nullptr, .len = 0 }; + HcfBigInteger retN = { .data = nullptr, .len = 0 }; + HcfBigInteger retSk = { .data = nullptr, .len = 0 }; + HcfBigInteger retPkX = { .data = nullptr, .len = 0 }; + HcfBigInteger retPkY = { .data = nullptr, .len = 0 }; + int retH = 0; + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_FP_P_BN, &retFp); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_A_BN, &retA); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_B_BN, &retB); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_G_X_BN, &retGX); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_G_Y_BN, &retGY); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_N_BN, &retN); + EXPECT_EQ(res, HCF_SUCCESS); + res = pubKey->getAsyKeySpecBigInteger(pubKey, ECC_PK_X_BN, &retPkX); + EXPECT_EQ(res, HCF_SUCCESS); + res = pubKey->getAsyKeySpecBigInteger(pubKey, ECC_PK_Y_BN, &retPkY); + EXPECT_EQ(res, HCF_SUCCESS); + res = priKey->getAsyKeySpecBigInteger(priKey, ECC_SK_BN, &retSk); + EXPECT_EQ(res, HCF_SUCCESS); + res = pubKey->getAsyKeySpecInt(pubKey, ECC_H_INT, &retH); + EXPECT_EQ(res, HCF_SUCCESS); + HcfBigInteger params[9]; + params[0].data = retFp.data; + params[0].len = retFp.len; + params[1].data = retA.data; + params[1].len = retA.len; + params[2].data = retB.data; + params[2].len = retB.len; + params[3].data = retGX.data; + params[3].len = retGX.len; + params[4].data = retGY.data; + params[4].len = retGY.len; + params[5].data = retN.data; + params[5].len = retN.len; + params[6].data = retPkX.data; + params[6].len = retPkX.len; + params[7].data = retPkY.data; + params[7].len = retPkY.len; + params[8].data = retSk.data; + params[8].len = retSk.len; + + HcfEccKeyPairParamsSpec eccKeyPairSpec = {}; + res = ConstructSm2256KeyPairParamsSpecByGet(&eccKeyPairSpec, params, retH); + HcfAsyKeyGeneratorBySpec *generatorSpec = nullptr; + res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast(&eccKeyPairSpec), &generatorSpec); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generatorSpec, nullptr); + + HcfKeyPair *dupKeyPair = nullptr; + res = generatorSpec->generateKeyPair(generatorSpec, &dupKeyPair); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(dupKeyPair, nullptr); + + HcfObjDestroy(dupKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(generatorSpec); +} +} diff --git a/test/unittest/src/crypto_sm2_cipher_test.cpp b/test/unittest/src/crypto_sm2_cipher_test.cpp index f263c12..836b0dd 100644 --- a/test/unittest/src/crypto_sm2_cipher_test.cpp +++ b/test/unittest/src/crypto_sm2_cipher_test.cpp @@ -888,4 +888,332 @@ HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest042, TestSize.Level0) HcfObjDestroy(generator); HcfObjDestroy(cipher); } + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest048, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest049, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(cipher, OAEP_MGF1_PSRC_UINT8ARR, &returnStr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest050, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, nullptr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest051, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(nullptr, SM2_MD_NAME_STR, &returnStr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest052, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr); + EXPECT_EQ(res, HCF_SUCCESS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + + HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest053, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(cipher, OAEP_MGF1_PSRC_UINT8ARR, &returnStr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest054, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, nullptr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest055, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(nullptr, SM2_MD_NAME_STR, &returnStr); + EXPECT_EQ(res, HCF_INVALID_PARAMS); + + HcfFree(returnStr); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest056, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + HcfBlob returnUint8Array = {.data = nullptr, .len = 0}; + res = cipher->getCipherSpecUint8Array(cipher, SM2_MD_NAME_STR, &returnUint8Array); + EXPECT_EQ(res, HCF_NOT_SUPPORT); + + HcfFree(returnUint8Array.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest057, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + EXPECT_EQ(res, HCF_SUCCESS); + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + HcfBlob pSource = {.data = nullptr, .len = 0}; + res = cipher->setCipherSpecUint8Array(cipher, SM2_MD_NAME_STR, pSource); + EXPECT_EQ(res, HCF_NOT_SUPPORT); + + HcfFree(pSource.data); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + HcfObjDestroy(cipher); +} + +HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest058, TestSize.Level0) +{ + HcfResult res = HCF_SUCCESS; + uint8_t plan[] = "this is sm2 cipher test!\0"; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); + EXPECT_EQ(res, HCF_SUCCESS); + 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 = nullptr, .len = 0}; + HcfCipherGeneratorSpi *cipher = nullptr; + CipherAttr params = { + .algo = HCF_ALG_SM2, + .md = HCF_OPENSSL_DIGEST_SM3, + }; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + + res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr); + EXPECT_EQ(res, HCF_SUCCESS); + char *returnStr = nullptr; + res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr); + EXPECT_EQ(res, HCF_SUCCESS); + res = cipher->doFinal(cipher, &input, &encoutput); + EXPECT_EQ(res, HCF_SUCCESS); + HcfFree(returnStr); + HcfObjDestroy(cipher); + + HcfBlob decoutput = {.data = nullptr, .len = 0}; + cipher = nullptr; + res = HcfCipherSm2CipherSpiCreate(¶ms, &cipher); + EXPECT_EQ(res, HCF_SUCCESS); + 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); + HcfObjDestroy(cipher); + EXPECT_STREQ((char *)plan, (char *)decoutput.data); + + HcfFree(encoutput.data); + HcfFree(decoutput.data); + + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} } diff --git a/test/unittest/src/crypto_sm2_sign_test.cpp b/test/unittest/src/crypto_sm2_sign_test.cpp index 48bfc17..4683aae 100644 --- a/test/unittest/src/crypto_sm2_sign_test.cpp +++ b/test/unittest/src/crypto_sm2_sign_test.cpp @@ -237,7 +237,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest014, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest016, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest015, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -252,7 +252,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest016, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest017, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest016, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -267,7 +267,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest017, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest019, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest017, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -286,7 +286,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest019, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest020, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest018, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -301,7 +301,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest020, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest022, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest019, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -320,7 +320,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest022, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest023, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest020, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -339,7 +339,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest023, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest025, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest021, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -354,7 +354,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest025, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest026, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest022, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -373,7 +373,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest026, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest027, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest023, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -396,7 +396,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest027, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest028, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest024, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -419,7 +419,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest028, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest029, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest025, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -446,7 +446,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest029, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest030, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest026, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -469,7 +469,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest030, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest031, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest027, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -493,7 +493,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest031, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest033, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest028, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -513,7 +513,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest033, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest034, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest029, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -537,7 +537,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest034, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest035, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest030, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -561,7 +561,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest035, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest036, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest031, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -584,7 +584,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest036, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest037, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest032, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -645,7 +645,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest037, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest038, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest033, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -677,7 +677,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest038, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest039, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest034, TestSize.Level0) { HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); @@ -716,7 +716,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest039, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest040, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest035, TestSize.Level0) { HcfAsyKeyGenerator *generator = nullptr; int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator); @@ -757,7 +757,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest040, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest041, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest036, TestSize.Level0) { HcfSignSpi *spiObj = nullptr; int32_t res = HcfSignSpiSm2Create(nullptr, &spiObj); @@ -766,7 +766,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest041, TestSize.Level0) ASSERT_EQ(spiObj, nullptr); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest042, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest037, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -777,7 +777,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest042, TestSize.Level0) ASSERT_EQ(res, HCF_INVALID_PARAMS); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest043, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest038, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -795,7 +795,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest043, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest045, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest039, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -818,7 +818,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest045, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest047, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest040, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -836,7 +836,7 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest047, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest049, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest041, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -900,7 +900,7 @@ static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input) } } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest051, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest042, TestSize.Level0) { StartRecordMallocNum(); HcfAsyKeyGenerator *generator = nullptr; @@ -994,7 +994,7 @@ static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input) } } -HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest052, TestSize.Level0) +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest043, TestSize.Level0) { StartRecordOpensslCallNum(); HcfAsyKeyGenerator *generator = nullptr; @@ -1040,4 +1040,322 @@ HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest052, TestSize.Level0) EndRecordOpensslCallNum(); } + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest044, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest045, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfBlob pSource = {.data = nullptr, .len = 0}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest046, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest047, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest048, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest049, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob pSource = {.data = nullptr, .len = 0}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest050, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest051, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest052, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + int32_t saltlen = 0; + res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, saltlen); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest053, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + int32_t returnInt = 0; + res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, &returnInt); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest054, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest055, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, &returnStr); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest056, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest057, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = sign->getSignSpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest058, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = sign->getSignSpecString(sign, PSS_MD_NAME_STR, &returnStr); + ASSERT_EQ(res, HCF_NOT_SUPPORT); + HcfObjDestroy(sign); +} + +// sign设置userid参数，进行签名，verify不设置参数进行验签 +HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest059, TestSize.Level0) +{ + HcfSign *sign = nullptr; + int32_t res = HcfSignCreate("SM2|SM3", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + 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 = nullptr; + res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + + free(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); +} } diff --git a/test/unittest/src/crypto_sm2_verify_test.cpp b/test/unittest/src/crypto_sm2_verify_test.cpp index e2303f2..30d847a 100644 --- a/test/unittest/src/crypto_sm2_verify_test.cpp +++ b/test/unittest/src/crypto_sm2_verify_test.cpp @@ -36,10 +36,10 @@ public: void SetUp(); void TearDown(); - static HcfKeyPair *sm2256KeyPair_; + static HcfKeyPair *g_sm2256KeyPair_; }; -HcfKeyPair *CryptoSm2VerifyTest::sm2256KeyPair_ = nullptr; +HcfKeyPair *CryptoSm2VerifyTest::g_sm2256KeyPair_ = nullptr; static const char *g_mockMessage = "hello world"; static HcfBlob g_mockInput = { @@ -62,14 +62,14 @@ void CryptoSm2VerifyTest::SetUpTestCase() ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - sm2256KeyPair_ = keyPair; + g_sm2256KeyPair_ = keyPair; HcfObjDestroy(generator); } void CryptoSm2VerifyTest::TearDownTestCase() { - HcfObjDestroy(sm2256KeyPair_); + HcfObjDestroy(g_sm2256KeyPair_); } static const char *GetMockClass(void) @@ -237,7 +237,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest014, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest016, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest015, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -245,14 +245,14 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest016, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest017, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest016, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -260,14 +260,14 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest017, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(nullptr, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(nullptr, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest019, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest017, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -275,18 +275,18 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest019, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest020, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest018, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -301,7 +301,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest020, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest022, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest019, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -309,7 +309,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest022, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -320,7 +320,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest022, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest023, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest020, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -328,7 +328,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest023, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -339,7 +339,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest023, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest025, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest021, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -354,7 +354,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest025, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest026, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest022, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -362,7 +362,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest026, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -373,7 +373,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest026, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest027, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest023, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -381,7 +381,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest027, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -396,7 +396,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest027, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest028, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest024, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -404,7 +404,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest028, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -419,7 +419,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest028, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest025, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -427,7 +427,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -448,7 +448,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -465,7 +465,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest026, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -473,7 +473,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -490,7 +490,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -503,7 +503,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest027, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -511,7 +511,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -532,7 +532,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -549,7 +549,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest028, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -557,7 +557,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -578,7 +578,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -595,7 +595,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -603,7 +603,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -624,7 +624,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -637,7 +637,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -645,7 +645,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -666,7 +666,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -683,7 +683,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0) { HcfSign *sign = nullptr; int32_t res = HcfSignCreate("SM2|SM3", &sign); @@ -691,7 +691,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, nullptr, sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -712,7 +712,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -729,7 +729,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -737,7 +737,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -752,7 +752,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest037, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -760,7 +760,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest037, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -779,7 +779,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest037, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest038, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0) { HcfVerify *verify = nullptr; int32_t res = HcfVerifyCreate("SM2|SM3", &verify); @@ -787,7 +787,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest038, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -806,7 +806,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest038, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest039, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0) { HcfVerifySpi *spiObj = nullptr; int32_t res = HcfVerifySpiSm2Create(nullptr, &spiObj); @@ -815,7 +815,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest039, TestSize.Level0) ASSERT_EQ(spiObj, nullptr); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest040, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -826,7 +826,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest040, TestSize.Level0) ASSERT_EQ(res, HCF_INVALID_PARAMS); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest043, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest037, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -849,7 +849,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest043, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest045, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest038, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -867,7 +867,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest045, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest046, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest039, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -891,7 +891,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest046, TestSize.Level0) HcfObjDestroy(spiObj); } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest048, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest040, TestSize.Level0) { HcfSignatureParams params = { .algo = HCF_ALG_SM2, @@ -915,7 +915,7 @@ static bool GetSignTestData(HcfBlob *out) if (res != HCF_SUCCESS) { return false; } - res = sign->init(sign, nullptr, CryptoSm2VerifyTest::sm2256KeyPair_->priKey); + res = sign->init(sign, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->priKey); if (res != HCF_SUCCESS) { HcfObjDestroy(sign); return false; @@ -940,7 +940,7 @@ static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out) if (res != HCF_SUCCESS) { continue; } - res = verify->init(verify, nullptr, CryptoSm2VerifyTest::sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->pubKey); if (res != HCF_SUCCESS) { HcfObjDestroy(verify); continue; @@ -955,7 +955,7 @@ static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out) } } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest050, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest041, TestSize.Level0) { HcfBlob out = { .data = nullptr, .len = 0 }; GetSignTestData(&out); @@ -967,7 +967,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest050, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -995,7 +995,7 @@ static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out) if (res != HCF_SUCCESS) { continue; } - res = verify->init(verify, nullptr, CryptoSm2VerifyTest::sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->pubKey); if (res != HCF_SUCCESS) { HcfObjDestroy(verify); continue; @@ -1010,7 +1010,7 @@ static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out) } } -HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0) +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest042, TestSize.Level0) { HcfBlob out = { .data = nullptr, .len = 0 }; ASSERT_EQ(GetSignTestData(&out), true); @@ -1022,7 +1022,7 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey); + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -1040,8 +1040,286 @@ HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0) EndRecordOpensslCallNum(); } -// Test verify signData from third-Party +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest043, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest044, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + HcfBlob pSource = {.data = nullptr, .len = 0}; + res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest045, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest046, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest047, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest048, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob pSource = {.data = nullptr, .len = 0}; + res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest049, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest050, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + uint8_t pSourceData[] = "1234567812345678\0"; + HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)}; + res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + int32_t saltlen = 0; + res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, saltlen); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(verify); +} + HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest052, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + int32_t *returnInt = nullptr; + res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, returnInt); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest053, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + int32_t returnInt = 0; + res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, &returnInt); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest054, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, &returnStr); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest055, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest056, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = verify->getVerifySpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr); + + ASSERT_NE(res, HCF_SUCCESS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest057, TestSize.Level0) +{ + HcfVerify *verify = nullptr; + int32_t res = HcfVerifyCreate("SM2|SM3", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + char *returnStr = nullptr; + res = verify->getVerifySpecString(verify, PSS_MD_NAME_STR, &returnStr); + + ASSERT_EQ(res, HCF_NOT_SUPPORT); + + HcfObjDestroy(verify); +} + +// Test verify signData from third-Party +HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest058, TestSize.Level0) { uint8_t pk[] = { 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, -- Gitee From 3bd5a275f802ed73b746a3299a987896f5a5254e Mon Sep 17 00:00:00 2001 From: xwb Date: Thu, 16 Nov 2023 01:56:17 +0000 Subject: [PATCH 2/2] =?UTF-8?q?add=20BrainPool=E3=80=81sm2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xwb --- frameworks/js/napi/crypto/src/napi_utils.cpp | 2 +- frameworks/key/key_utils.c | 2 +- interfaces/innerkits/common/result.h | 2 +- plugin/openssl_plugin/common/src/openssl_common.c | 8 ++++---- .../asy_key_generator/src/sm2_asy_key_generator_openssl.c | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/frameworks/js/napi/crypto/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp index ab540cc..017eec9 100644 --- a/frameworks/js/napi/crypto/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -1551,7 +1551,7 @@ bool BuildIntenceParterToNapiValue(napi_env env, HcfEccCommParamsSpec *blob, nap napi_value algName; size_t algNameLength = HcfStrlen(blob->base.algName); if (!algNameLength) { - LOGE("algName is enpty!"); + LOGE("algName is empty!"); return false; } napi_status status = napi_create_string_utf8(env, blob->base.algName, algNameLength, &algName); diff --git a/frameworks/key/key_utils.c b/frameworks/key/key_utils.c index 677c3a8..674af0e 100644 --- a/frameworks/key/key_utils.c +++ b/frameworks/key/key_utils.c @@ -25,7 +25,7 @@ HcfResult CopyAsyKeyParamsSpec(const HcfAsyKeyParamsSpec *srcSpec, HcfAsyKeyPara { size_t srcAlgNameLen = HcfStrlen(srcSpec->algName); if (!srcAlgNameLen) { - LOGE("algName is enpty!"); + LOGE("algName is empty!"); return HCF_INVALID_PARAMS; } destSpec->algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0); diff --git a/interfaces/innerkits/common/result.h b/interfaces/innerkits/common/result.h index 9e2a576..38de2d6 100644 --- a/interfaces/innerkits/common/result.h +++ b/interfaces/innerkits/common/result.h @@ -25,7 +25,7 @@ typedef enum HcfResult { HCF_NOT_SUPPORT = -10002, /** Indicates that memory malloc fails. */ - HCF_ERR_MALLOC = 20001, + HCF_ERR_MALLOC = -20001, /** Indicates that memory copy fails. */ HCF_ERR_COPY = -20002, diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 4aa4403..2d526a7 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -150,7 +150,7 @@ HcfResult GetAlgNameByBits(int32_t keyLen, char **algName) if (ALG_NAME_TYPE_MAP[i].bits == keyLen) { size_t srcAlgNameLen = HcfStrlen(ALG_NAME_TYPE_MAP[i].algName); if (!srcAlgNameLen) { - LOGE("algName is enpty!"); + LOGE("algName is empty!"); return HCF_ERR_MALLOC; } *algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0); @@ -259,7 +259,7 @@ HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString) } size_t mdLen = HcfStrlen(tmp); if (!mdLen) { - LOGE("mdLen is enpty!"); + LOGE("mdLen is empty!"); return HCF_ERR_MALLOC; } char *mdStr = (char *)HcfMalloc(mdLen + 1, 0); @@ -280,7 +280,7 @@ HcfResult GetRsaSpecStringMGF(char **returnString) } size_t mgf1Len = HcfStrlen(HCF_OPENSSL_MGF1); if (!mgf1Len) { - LOGE("mgf1Len is enpty!"); + LOGE("mgf1Len is empty!"); return HCF_ERR_MALLOC; } char *mgf1Str = (char *)HcfMalloc(mgf1Len + 1, 0); @@ -301,7 +301,7 @@ HcfResult GetSm2SpecStringSm3(char **returnString) } size_t sm2Len = HcfStrlen(HCF_OPENSSL_DIGEST_SM3_STR); if (!sm2Len) { - LOGE("sm2Len is enpty!"); + LOGE("sm2Len is empty!"); return HCF_ERR_MALLOC; } char *sm2Str = (char *)HcfMalloc(sm2Len + 1, 0); diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c index 008fc39..c9d3b81 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c @@ -939,7 +939,7 @@ static HcfResult GetCurveName(const HcfKey *self, bool isPriavte, char **returnS size_t len = HcfStrlen(tmp); if (!len) { - LOGE("tmp is enpty!"); + LOGE("tmp is empty!"); return HCF_INVALID_PARAMS; } *returnString = (char *)HcfMalloc(len + 1, 0); -- Gitee