diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..cd066e89dd7d549f365249b781375bbaf08708b5 --- /dev/null +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HCF_OPENSSL_ADAPTER_H +#define HCF_OPENSSL_ADAPTER_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +BIGNUM *Openssl_BN_dup(const BIGNUM *a); +void Openssl_BN_clear(BIGNUM *a); +void Openssl_BN_clear_free(BIGNUM *a); + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid); +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); +int Openssl_EC_KEY_generate_key(EC_KEY *eckey); +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key); +int Openssl_EC_KEY_check_key(const EC_KEY *key); +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key); +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key); +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key); +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp); +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length); +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag); +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags); +void Openssl_EC_KEY_free(EC_KEY *key); +void Openssl_EC_POINT_free(EC_POINT *point); + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void); +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx); +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count); +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen); +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count); +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen); + +EVP_PKEY *Openssl_EVP_PKEY_new(void); +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key); +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey); + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c new file mode 100644 index 0000000000000000000000000000000000000000..4d0b40c2e10dee8ae547280a973a518bd4744e43 --- /dev/null +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_adapter.h" + +#include "log.h" +#include "result.h" + +BIGNUM *Openssl_BN_dup(const BIGNUM *a) +{ + return BN_dup(a); +} + +void Openssl_BN_clear(BIGNUM *a) +{ + BN_clear(a); +} + +void Openssl_BN_clear_free(BIGNUM *a) +{ + BN_clear_free(a); +} + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid) +{ + return EC_KEY_new_by_curve_name(nid); +} + +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group) +{ + return EC_POINT_dup(src, group); +} + +int Openssl_EC_KEY_generate_key(EC_KEY *eckey) +{ + return EC_KEY_generate_key(eckey); +} + +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub) +{ + return EC_KEY_set_public_key(key, pub); +} + +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key) +{ + return EC_KEY_set_private_key(key, priv_key); +} + +int Openssl_EC_KEY_check_key(const EC_KEY *key) +{ + return EC_KEY_check_key(key); +} + +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key) +{ + return EC_KEY_get0_public_key(key); +} + +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key) +{ + return EC_KEY_get0_private_key(key); +} + +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key) +{ + return EC_KEY_get0_group(key); +} + +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp) +{ + return i2d_EC_PUBKEY(a, pp); +} + +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out) +{ + return i2d_ECPrivateKey(key, out); +} + +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) +{ + return d2i_EC_PUBKEY(a, pp, length); +} + +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len) +{ + return d2i_ECPrivateKey(key, in, len); +} + +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag) +{ + EC_KEY_set_asn1_flag(key, flag); +} + +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags) +{ + EC_KEY_set_enc_flags(eckey, flags); +} + +void Openssl_EC_KEY_free(EC_KEY *key) +{ + EC_KEY_free(key); +} + +void Openssl_EC_POINT_free(EC_POINT *point) +{ + EC_POINT_free(point); +} + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void) +{ + return EVP_MD_CTX_new(); +} + +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx) +{ + EVP_MD_CTX_free(ctx); +} + +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + return EVP_DigestSignInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + return EVP_DigestSignUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen) +{ + return EVP_DigestSignFinal(ctx, sigret, siglen); +} + +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + return EVP_DigestVerifyInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + return EVP_DigestVerifyUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen) +{ + return EVP_DigestVerifyFinal(ctx, sig, siglen); +} + +EVP_PKEY *Openssl_EVP_PKEY_new(void) +{ + return EVP_PKEY_new(); +} + +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) +{ + return EVP_PKEY_assign_EC_KEY(pkey, key); +} + +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey) +{ + EVP_PKEY_free(pkey); +} + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) +{ + return EVP_PKEY_CTX_new(pkey, e); +} + +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx) +{ + return EVP_PKEY_derive_init(ctx); +} + +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer) +{ + return EVP_PKEY_derive_set_peer(ctx, peer); +} + +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen) +{ + return EVP_PKEY_derive(ctx, key, keylen); +} + +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) +{ + EVP_PKEY_CTX_free(ctx); +} \ No newline at end of file diff --git a/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c b/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c index de061eda61997e0824c109f0730b6b07be45f698..2ab284af9c793cc1bbe1279e8fff92732ac4bb6c 100644 --- a/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/key_agreement/src/ecdh_openssl.c @@ -19,6 +19,7 @@ #include #include "algorithm_parameter.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "log.h" @@ -33,26 +34,26 @@ typedef struct { static EVP_PKEY *NewPKeyByEccPubKey(int32_t curveId, HcfOpensslEccPubKey *publicKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return NULL; } - if (EC_KEY_set_public_key(ecKey, (publicKey->pk)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_public_key(ecKey, (publicKey->pk)) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return NULL; } return pKey; @@ -60,26 +61,26 @@ static EVP_PKEY *NewPKeyByEccPubKey(int32_t curveId, HcfOpensslEccPubKey *public static EVP_PKEY *NewPKeyByEccPriKey(int32_t curveId, HcfOpensslEccPriKey *privateKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return NULL; } - if (EC_KEY_set_private_key(ecKey, (privateKey->sk)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_private_key(ecKey, (privateKey->sk)) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); EC_KEY_free(ecKey); return NULL; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return NULL; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return NULL; } return pKey; @@ -87,41 +88,41 @@ static EVP_PKEY *NewPKeyByEccPriKey(int32_t curveId, HcfOpensslEccPriKey *privat static HcfResult EcdhDerive(EVP_PKEY *priPKey, EVP_PKEY *pubPKey, HcfBlob *returnSecret) { - EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(priPKey, NULL); + EVP_PKEY_CTX *ctx = Openssl_EVP_PKEY_CTX_new(priPKey, NULL); if (ctx == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_derive_init(ctx) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive_init(ctx) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_derive_set_peer(ctx, pubPKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive_set_peer(ctx, pubPKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } size_t maxLen; - if (EVP_PKEY_derive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_CRYPTO_OPERATION; } uint8_t *secretData = (uint8_t *)HcfMalloc(maxLen, 0); if (secretData == NULL) { LOGE("Failed to allocate secretData memory!"); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); return HCF_ERR_MALLOC; } size_t actualLen = maxLen; - if (EVP_PKEY_derive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_derive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); HcfFree(secretData); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_CTX_free(ctx); + Openssl_EVP_PKEY_CTX_free(ctx); if (actualLen > maxLen) { LOGE("signature data too long."); HcfFree(secretData); @@ -176,8 +177,8 @@ static HcfResult EngineGenerateSecret(HcfKeyAgreementSpi *self, HcfPriKey *priKe } int32_t res = EcdhDerive(priPKey, pubPKey, returnSecret); - EVP_PKEY_free(priPKey); - EVP_PKEY_free(pubPKey); + Openssl_EVP_PKEY_free(priPKey); + Openssl_EVP_PKEY_free(pubPKey); LOGI("end ..."); return res; } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c index 89c0e46c56e91261325eba6eeed1cdd217a1e12c..8701015a7c556fafb7f2a7d5fc55b9b196a23831 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c @@ -19,6 +19,7 @@ #include #include "algorithm_parameter.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "log.h" @@ -89,7 +90,7 @@ static void DestroyEcdsaSign(HcfObjectBase *self) return; } HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; - EVP_MD_CTX_destroy(impl->ctx); + Openssl_EVP_MD_CTX_free(impl->ctx); impl->ctx = NULL; HcfFree(impl); } @@ -103,7 +104,7 @@ static void DestroyEcdsaVerify(HcfObjectBase *self) return; } HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; - EVP_MD_CTX_destroy(impl->ctx); + Openssl_EVP_MD_CTX_free(impl->ctx); impl->ctx = NULL; HcfFree(impl); } @@ -126,34 +127,34 @@ static HcfResult EngineSignInit(HcfSignSpi *self, HcfParamsSpec *params, HcfPriK LOGE("Repeated initialization is not allowed."); return HCF_INVALID_PARAMS; } - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_private_key(ecKey, ((HcfOpensslEccPriKey *)privateKey)->sk) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_private_key(ecKey, ((HcfOpensslEccPriKey *)privateKey)->sk) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_DigestSignInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); impl->status = INITIALIZED; LOGI("end ..."); return HCF_SUCCESS; @@ -174,7 +175,7 @@ static HcfResult EngineSignUpdate(HcfSignSpi *self, HcfBlob *data) LOGE("Sign object has not been initialized."); return HCF_INVALID_PARAMS; } - if (EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -196,7 +197,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret HcfSignSpiEcdsaOpensslImpl *impl = (HcfSignSpiEcdsaOpensslImpl *)self; if (IsBlobValid(data)) { - if (EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -207,7 +208,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_INVALID_PARAMS; } size_t maxLen; - if (EVP_DigestSignFinal(impl->ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -217,7 +218,7 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret return HCF_ERR_MALLOC; } size_t actualLen = maxLen; - if (EVP_DigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; @@ -252,34 +253,34 @@ static HcfResult EngineVerifyInit(HcfVerifySpi *self, HcfParamsSpec *params, Hcf LOGE("Repeated initialization is not allowed."); return HCF_INVALID_PARAMS; } - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_public_key(ecKey, ((HcfOpensslEccPubKey *)publicKey)->pk) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_public_key(ecKey, ((HcfOpensslEccPubKey *)publicKey)->pk) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *pKey = Openssl_EVP_PKEY_new(); if (pKey == NULL) { HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_PKEY_assign_EC_KEY(pKey, ecKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); - EC_KEY_free(ecKey); + Openssl_EVP_PKEY_free(pKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EVP_DigestVerifyInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyInit(impl->ctx, NULL, impl->digestAlg, NULL, pKey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY_free(pKey); + Openssl_EVP_PKEY_free(pKey); impl->status = INITIALIZED; LOGI("end ..."); return HCF_SUCCESS; @@ -301,7 +302,7 @@ static HcfResult EngineVerifyUpdate(HcfVerifySpi *self, HcfBlob *data) LOGE("Verify object has not been initialized."); return HCF_INVALID_PARAMS; } - if (EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } @@ -323,7 +324,7 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign HcfVerifySpiEcdsaOpensslImpl *impl = (HcfVerifySpiEcdsaOpensslImpl *)self; if (IsBlobValid(data)) { - if (EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyUpdate(impl->ctx, data->data, data->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } @@ -333,7 +334,7 @@ static bool EngineVerifyDoFinal(HcfVerifySpi *self, HcfBlob *data, HcfBlob *sign LOGE("The message has not been transferred."); return false; } - if (EVP_DigestVerifyFinal(impl->ctx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EVP_DigestVerifyFinal(impl->ctx, signatureData->data, signatureData->len) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); return false; } @@ -355,9 +356,6 @@ HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnO return HCF_INVALID_PARAMS; } const EVP_MD *opensslAlg = GetOpensslDigestAlg(params->md); - if (opensslAlg == NULL) { - return HCF_INVALID_PARAMS; - } HcfSignSpiEcdsaOpensslImpl *returnImpl = (HcfSignSpiEcdsaOpensslImpl *)HcfMalloc( sizeof(HcfSignSpiEcdsaOpensslImpl), 0); @@ -373,7 +371,7 @@ HcfResult HcfSignSpiEcdsaCreate(HcfSignatureParams *params, HcfSignSpi **returnO returnImpl->curveId = curveId; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = EVP_MD_CTX_create(); + returnImpl->ctx = Openssl_EVP_MD_CTX_new(); if (returnImpl->ctx == NULL) { LOGE("Failed to allocate ctx memory!"); HcfFree(returnImpl); @@ -398,9 +396,6 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret return HCF_INVALID_PARAMS; } const EVP_MD *opensslAlg = GetOpensslDigestAlg(params->md); - if (opensslAlg == NULL) { - return HCF_INVALID_PARAMS; - } HcfVerifySpiEcdsaOpensslImpl *returnImpl = (HcfVerifySpiEcdsaOpensslImpl *)HcfMalloc( sizeof(HcfVerifySpiEcdsaOpensslImpl), 0); @@ -416,7 +411,7 @@ HcfResult HcfVerifySpiEcdsaCreate(HcfSignatureParams *params, HcfVerifySpi **ret returnImpl->curveId = curveId; returnImpl->digestAlg = opensslAlg; returnImpl->status = UNINITIALIZED; - returnImpl->ctx = EVP_MD_CTX_create(); + returnImpl->ctx = Openssl_EVP_MD_CTX_new(); if (returnImpl->ctx == NULL) { LOGE("Failed to allocate ctx memory!"); HcfFree(returnImpl); diff --git a/plugin/openssl_plugin/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 f27cdca217248d3244caa26bbd2c8530de8e78d5..671e0aacda7ad8787c3432a3fdd9a270faefd002 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 @@ -16,12 +16,11 @@ #include "ecc_asy_key_generator_openssl.h" #include "securec.h" -#include "openssl/pem.h" -#include "openssl/x509.h" #include "algorithm_parameter.h" #include "log.h" #include "memory.h" +#include "openssl_adapter.h" #include "openssl_class.h" #include "openssl_common.h" #include "utils.h" @@ -39,46 +38,46 @@ typedef struct { static HcfResult NewEcKeyPairByOpenssl(int32_t curveId, EC_POINT **returnPubKey, BIGNUM **returnPriKey) { - EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(curveId); if (ecKey == NULL) { LOGE("new ec key failed."); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_generate_key(ecKey) <= 0) { + if (Openssl_EC_KEY_generate_key(ecKey) <= 0) { LOGE("generate ec key failed."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_check_key(ecKey) <= 0) { + if (Openssl_EC_KEY_check_key(ecKey) <= 0) { LOGE("check key fail."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - const EC_POINT *pubKey = EC_KEY_get0_public_key(ecKey); - const BIGNUM *priKey = EC_KEY_get0_private_key(ecKey); - const EC_GROUP *group = EC_KEY_get0_group(ecKey); + const EC_POINT *pubKey = Openssl_EC_KEY_get0_public_key(ecKey); + const BIGNUM *priKey = Openssl_EC_KEY_get0_private_key(ecKey); + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); if ((pubKey == NULL) || (priKey == NULL) || (group == NULL)) { LOGE("ec key is invalid."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EC_POINT *newPubKey = EC_POINT_dup(pubKey, group); + EC_POINT *newPubKey = Openssl_EC_POINT_dup(pubKey, group); if (newPubKey == NULL) { LOGE("copy pubKey fail."); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - BIGNUM *newPriKey = BN_dup(priKey); + BIGNUM *newPriKey = Openssl_BN_dup(priKey); if (newPriKey == NULL) { LOGE("copy priKey fail."); - EC_KEY_free(ecKey); - EC_POINT_free(newPubKey); + Openssl_EC_KEY_free(ecKey); + Openssl_EC_POINT_free(newPubKey); return HCF_ERR_CRYPTO_OPERATION; } *returnPubKey = newPubKey; *returnPriKey = newPriKey; - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_SUCCESS; } @@ -222,25 +221,21 @@ static HcfResult GetEccPubKeyEncoded(HcfKey *self, HcfBlob *returnBlob) } HcfOpensslEccPubKey *impl = (HcfOpensslEccPubKey *)self; - if (impl->pk == NULL) { - LOGE("Empty public key!"); - return HCF_INVALID_PARAMS; - } - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { LOGE("EC_KEY_new_by_curve_name fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_public_key(ecKey, impl->pk) <= 0) { + if (Openssl_EC_KEY_set_public_key(ecKey, impl->pk) <= 0) { LOGE("EC_KEY_set_public_key fail."); HcfPrintOpensslError(); EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } unsigned char *returnData = NULL; - int returnDataLen = i2d_EC_PUBKEY(ecKey, &returnData); - EC_KEY_free(ecKey); + int returnDataLen = Openssl_i2d_EC_PUBKEY(ecKey, &returnData); + Openssl_EC_KEY_free(ecKey); if (returnDataLen <= 0) { LOGE("i2d_EC_PUBKEY fail"); HcfPrintOpensslError(); @@ -264,28 +259,23 @@ static HcfResult GetEccPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob) } HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self; - if (impl->sk == NULL) { - LOGE("Empty private key!"); - return HCF_INVALID_PARAMS; - } - - EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId); + EC_KEY *ecKey = Openssl_EC_KEY_new_by_curve_name(impl->curveId); if (ecKey == NULL) { LOGE("EC_KEY_new_by_curve_name fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (EC_KEY_set_private_key(ecKey, (impl->sk)) != HCF_OPENSSL_SUCCESS) { + if (Openssl_EC_KEY_set_private_key(ecKey, (impl->sk)) != HCF_OPENSSL_SUCCESS) { LOGE("EC_KEY_set_private_key fail."); HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EC_KEY_set_asn1_flag(ecKey, OPENSSL_EC_NAMED_CURVE); - EC_KEY_set_enc_flags(ecKey, EC_PKEY_NO_PUBKEY); + Openssl_EC_KEY_set_asn1_flag(ecKey, OPENSSL_EC_NAMED_CURVE); + Openssl_EC_KEY_set_enc_flags(ecKey, EC_PKEY_NO_PUBKEY); unsigned char *returnData = NULL; - int returnDataLen = i2d_ECPrivateKey(ecKey, &returnData); - EC_KEY_free(ecKey); + int returnDataLen = Openssl_i2d_ECPrivateKey(ecKey, &returnData); + Openssl_EC_KEY_free(ecKey); if (returnDataLen <= 0) { LOGE("i2d_ECPrivateKey fail."); HcfPrintOpensslError(); @@ -306,7 +296,7 @@ static void EccPriKeyClearMem(HcfPriKey *self) return; } HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self; - BN_clear(impl->sk); + Openssl_BN_clear(impl->sk); } static HcfResult CreateEccPubKey(int32_t curveId, EC_POINT *pubKey, HcfOpensslEccPubKey **returnObj) @@ -368,29 +358,29 @@ static HcfResult CreateEccKeyPair(HcfOpensslEccPubKey *pubKey, HcfOpensslEccPriK static HcfResult ConvertEcPubKeyByOpenssl(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpensslEccPubKey **returnPubKey) { const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data); - EC_KEY *ecKey = d2i_EC_PUBKEY(NULL, &tmpData, pubKeyBlob->len); + EC_KEY *ecKey = Openssl_d2i_EC_PUBKEY(NULL, &tmpData, pubKeyBlob->len); if (ecKey == NULL) { LOGE("d2i_EC_PUBKEY fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - const EC_POINT *pubKey = EC_KEY_get0_public_key(ecKey); - const EC_GROUP *group = EC_KEY_get0_group(ecKey); + const EC_POINT *pubKey = Openssl_EC_KEY_get0_public_key(ecKey); + const EC_GROUP *group = Openssl_EC_KEY_get0_group(ecKey); if (pubKey == NULL || group == NULL) { LOGE("ec key is invalid."); HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - EC_POINT *newPubKey = EC_POINT_dup(pubKey, group); - EC_KEY_free(ecKey); + EC_POINT *newPubKey = Openssl_EC_POINT_dup(pubKey, group); + Openssl_EC_KEY_free(ecKey); if (newPubKey == NULL) { LOGE("copy pubKey fail."); return HCF_ERR_CRYPTO_OPERATION; } int32_t res = CreateEccPubKey(curveId, newPubKey, returnPubKey); if (res != HCF_SUCCESS) { - EC_POINT_free(newPubKey); + Openssl_EC_POINT_free(newPubKey); return res; } return HCF_SUCCESS; @@ -399,28 +389,28 @@ static HcfResult ConvertEcPubKeyByOpenssl(int32_t curveId, HcfBlob *pubKeyBlob, static HcfResult ConvertEcPriKeyByOpenssl(int32_t curveId, HcfBlob *priKeyBlob, HcfOpensslEccPriKey **returnPriKey) { const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data); - EC_KEY *ecKey = d2i_ECPrivateKey(NULL, &tmpData, priKeyBlob->len); + EC_KEY *ecKey = Openssl_d2i_ECPrivateKey(NULL, &tmpData, priKeyBlob->len); if (ecKey == NULL) { LOGE("d2i_ECPrivateKey fail"); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - const BIGNUM *priKey = EC_KEY_get0_private_key(ecKey); + const BIGNUM *priKey = Openssl_EC_KEY_get0_private_key(ecKey); if (priKey == NULL) { LOGE("ec key is invalid."); HcfPrintOpensslError(); - EC_KEY_free(ecKey); + Openssl_EC_KEY_free(ecKey); return HCF_ERR_CRYPTO_OPERATION; } - BIGNUM *newPriKey = BN_dup(priKey); - EC_KEY_free(ecKey); + BIGNUM *newPriKey = Openssl_BN_dup(priKey); + Openssl_EC_KEY_free(ecKey); if (newPriKey == NULL) { LOGE("copy priKey fail."); return HCF_ERR_CRYPTO_OPERATION; } int32_t res = CreateEccPriKey(curveId, newPriKey, returnPriKey); if (res != HCF_SUCCESS) { - BN_clear_free(newPriKey); + Openssl_BN_clear_free(newPriKey); return res; } return HCF_SUCCESS; @@ -497,15 +487,15 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * HcfOpensslEccPubKey *pubKey = NULL; res = CreateEccPubKey(impl->curveId, ecPubKey, &pubKey); if (res != HCF_SUCCESS) { - EC_POINT_free(ecPubKey); - BN_clear_free(ecPriKey); + Openssl_EC_POINT_free(ecPubKey); + Openssl_BN_clear_free(ecPriKey); return res; } HcfOpensslEccPriKey *priKey = NULL; res = CreateEccPriKey(impl->curveId, ecPriKey, &priKey); if (res != HCF_SUCCESS) { HcfObjDestroy(pubKey); - BN_clear_free(ecPriKey); + Openssl_BN_clear_free(ecPriKey); return res; } HcfOpensslEccKeyPair *returnKeyPair = (HcfOpensslEccKeyPair *)HcfMalloc(sizeof(HcfOpensslEccKeyPair), 0); diff --git a/plugin/plugin.gni b/plugin/plugin.gni index 245b7cf160234225f6483dff5e561acd612564d2..4004805426391afc30c96510574368176bc75ca8 100644 --- a/plugin/plugin.gni +++ b/plugin/plugin.gni @@ -38,6 +38,7 @@ plugin_signature_files = [ ] plugin_common_files = [ + "${plugin_path}/openssl_plugin/common/src/openssl_adapter.c", "${plugin_path}/openssl_plugin/common/src/openssl_common.c", "${plugin_path}/openssl_plugin/common/src/rsa_openssl_common.c", ] diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 8cfff6a12d35a0c2191d081fac448b9fa7f5006e..899265137b617933c669e2070e591b1316880ab1 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -48,6 +48,7 @@ ohos_unittest("crypto_framework_test") { ] sources += framework_files + plugin_files + sources -= [ "//base/security/crypto_framework/plugin/openssl_plugin/common/src/openssl_adapter.c" ] sources += [ "//base/security/crypto_framework/common/src/blob.c", "//base/security/crypto_framework/common/src/hcf_parcel.c", @@ -57,6 +58,7 @@ ohos_unittest("crypto_framework_test") { "//base/security/crypto_framework/common/src/params_parser.c", "//base/security/crypto_framework/common/src/utils.c", "src/memory_mock.c", + "src/openssl_adapter_mock.c", ] cflags = [ "-DHILOG_ENABLE" ] if (target_cpu == "arm") { diff --git a/test/unittest/include/memory_mock.h b/test/unittest/include/memory_mock.h index 06859a8a3f122a184badaa6be9934fb61493b727..0647a53453c3b5271bb335ce6a2fcef3db260db5 100755 --- a/test/unittest/include/memory_mock.h +++ b/test/unittest/include/memory_mock.h @@ -23,6 +23,11 @@ extern "C" { #endif void SetMockFlag(bool flag); +void StartRecordMallocNum(void); +void EndRecordMallocNum(void); +uint32_t GetMallocNum(void); +void ResetRecordMallocNum(void); +void SetMockMallocIndex(uint32_t index); #ifdef __cplusplus } diff --git a/test/unittest/include/openssl_adapter_mock.h b/test/unittest/include/openssl_adapter_mock.h new file mode 100644 index 0000000000000000000000000000000000000000..2d37586beaac688905df60d485cec9485c959848 --- /dev/null +++ b/test/unittest/include/openssl_adapter_mock.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OPENSSL_ADAPTER_MOCK_H +#define OPENSSL_ADAPTER_MOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void StartRecordOpensslCallNum(void); +uint32_t GetOpensslCallNum(void); +void ResetOpensslCallNum(void); +void SetOpensslCallMockIndex(uint32_t index); +void EndRecordOpensslCallNum(void); + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp b/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp index 699d5f7362a7ba7c96bb2d7c5cde5c8b0354c590..c02f59423dda10d0c5871788b15a9645d68956e1 100644 --- a/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp @@ -17,7 +17,11 @@ #include "securec.h" #include "asy_key_generator.h" +#include "ecc_asy_key_generator_openssl.h" #include "blob.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "params_parser.h" using namespace std; using namespace testing::ext; @@ -45,38 +49,38 @@ const int ECC384_PRI_KEY_LEN = 64; const int ECC512_PUB_KEY_LEN = 158; const int ECC512_PRI_KEY_LEN = 82; -static uint8_t mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, +uint8_t g_mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207, 141, 146, 235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181, 172, 192, 2, 99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 }; -static uint8_t mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, 147, 222, 43, +uint8_t g_mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, 147, 222, 43, 252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198, 19, 160, 7, 6, 5, 43, 129, 4, 0, 33 }; -static uint8_t mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, +uint8_t g_mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 3, 66, 0, 4, 65, 43, 59, 227, 32, 51, 44, 104, 47, 135, 97, 144, 91, 70, 231, 67, 2, 214, 197, 176, 161, 160, 227, 133, 158, 30, 118, 217, 243, 155, 88, 55, 214, 86, 86, 122, 166, 64, 111, 2, 226, 93, 163, 194, 210, 74, 18, 63, 173, 113, 249, 196, 126, 165, 222, 230, 190, 101, 241, 95, 102, 174, 252, 38 }; -static uint8_t mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45, +uint8_t g_mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45, 68, 72, 231, 43, 72, 243, 113, 255, 60, 232, 203, 151, 65, 80, 6, 36, 112, 247, 186, 106, 148, 43, 170, 204, 23, 189, 191, 160, 10, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7 }; -static uint8_t mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 48, 118, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, +uint8_t g_mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 48, 118, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 5, 43, 129, 4, 0, 34, 3, 98, 0, 4, 149, 237, 84, 7, 62, 114, 48, 106, 64, 227, 243, 253, 90, 170, 184, 80, 174, 159, 72, 117, 16, 24, 213, 146, 184, 159, 33, 209, 36, 143, 227, 11, 113, 228, 128, 13, 181, 195, 235, 12, 255, 85, 187, 197, 109, 82, 242, 226, 186, 53, 128, 9, 133, 4, 170, 96, 150, 94, 197, 196, 107, 120, 55, 159, 181, 208, 249, 176, 108, 6, 166, 253, 221, 156, 139, 140, 124, 240, 11, 194, 154, 139, 62, 218, 170, 61, 12, 147, 7, 146, 243, 158, 103, 195, 123, 156 }; -static uint8_t mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 48, 62, 2, 1, 1, 4, 48, 137, 184, 12, 183, 201, +uint8_t g_mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 48, 62, 2, 1, 1, 4, 48, 137, 184, 12, 183, 201, 211, 124, 203, 165, 9, 229, 68, 46, 17, 14, 14, 109, 195, 0, 206, 248, 21, 53, 72, 66, 3, 244, 165, 248, 217, 176, 121, 155, 225, 222, 134, 155, 241, 59, 16, 253, 237, 158, 11, 221, 252, 58, 251, 160, 7, 6, 5, 43, 129, 4, 0, 34 }; -static uint8_t mockEcc512PubKeyBlobData[ECC512_PUB_KEY_LEN] = { 48, 129, 155, 48, 16, 6, 7, 42, 134, 72, 206, +uint8_t g_mockEcc512PubKeyBlobData[ECC512_PUB_KEY_LEN] = { 48, 129, 155, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 5, 43, 129, 4, 0, 35, 3, 129, 134, 0, 4, 0, 149, 60, 46, 252, 220, 227, 253, 219, 250, 60, 232, 80, 190, 119, 38, 79, 202, 173, 35, 126, 228, 244, 207, 174, 191, 250, 147, 188, 22, 132, 125, 44, 26, 57, 242, 203, 192, 100, 65, 185, 250, 80, 246, 76, 37, 242, 78, 64, 152, 47, 172, 165, 229, 99, 247, 61, 91, 152, 144, @@ -84,48 +88,48 @@ static uint8_t mockEcc512PubKeyBlobData[ECC512_PUB_KEY_LEN] = { 48, 129, 155, 48 207, 159, 210, 113, 194, 174, 170, 194, 129, 215, 209, 50, 217, 204, 48, 53, 92, 231, 57, 179, 170, 6, 26, 77, 187, 181, 35, 254, 17, 216, 205, 118, 104, 89, 155, 145, 28, 61, 169, 113, 195, 55, 13, 125, 6, 168, 156 }; -static uint8_t mockEcc512PriKeyBlobData[ECC512_PRI_KEY_LEN] = { 48, 80, 2, 1, 1, 4, 66, 0, 210, 135, 140, 70, +uint8_t g_mockEcc512PriKeyBlobData[ECC512_PRI_KEY_LEN] = { 48, 80, 2, 1, 1, 4, 66, 0, 210, 135, 140, 70, 98, 28, 121, 169, 5, 202, 132, 165, 11, 56, 9, 110, 32, 9, 146, 185, 239, 69, 113, 79, 213, 24, 165, 194, 147, 209, 223, 187, 100, 6, 149, 4, 56, 235, 120, 152, 146, 252, 92, 21, 222, 3, 182, 68, 39, 222, 49, 192, 154, 126, 126, 243, 18, 99, 136, 199, 234, 134, 232, 13, 128, 160, 7, 6, 5, 43, 129, 4, 0, 35 }; -static HcfBlob mockEcc224PubKeyBlob = { - .data = mockEcc224PubKeyBlobData, +HcfBlob g_mockEcc224PubKeyBlob = { + .data = g_mockEcc224PubKeyBlobData, .len = ECC224_PUB_KEY_LEN }; -static HcfBlob mockEcc224PriKeyBlob = { - .data = mockEcc224PriKeyBlobData, +HcfBlob g_mockEcc224PriKeyBlob = { + .data = g_mockEcc224PriKeyBlobData, .len = ECC224_PRI_KEY_LEN }; -static HcfBlob mockEcc256PubKeyBlob = { - .data = mockEcc256PubKeyBlobData, +HcfBlob g_mockEcc256PubKeyBlob = { + .data = g_mockEcc256PubKeyBlobData, .len = ECC256_PUB_KEY_LEN }; -static HcfBlob mockEcc256PriKeyBlob = { - .data = mockEcc256PriKeyBlobData, +HcfBlob g_mockEcc256PriKeyBlob = { + .data = g_mockEcc256PriKeyBlobData, .len = ECC256_PRI_KEY_LEN }; -static HcfBlob mockEcc384PubKeyBlob = { - .data = mockEcc384PubKeyBlobData, +HcfBlob g_mockEcc384PubKeyBlob = { + .data = g_mockEcc384PubKeyBlobData, .len = ECC384_PUB_KEY_LEN }; -static HcfBlob mockEcc384PriKeyBlob = { - .data = mockEcc384PriKeyBlobData, +HcfBlob g_mockEcc384PriKeyBlob = { + .data = g_mockEcc384PriKeyBlobData, .len = ECC384_PRI_KEY_LEN }; -static HcfBlob mockEcc512PubKeyBlob = { - .data = mockEcc512PubKeyBlobData, +HcfBlob g_mockEcc512PubKeyBlob = { + .data = g_mockEcc512PubKeyBlobData, .len = ECC512_PUB_KEY_LEN }; -static HcfBlob mockEcc512PriKeyBlob = { - .data = mockEcc512PriKeyBlobData, +HcfBlob g_mockEcc512PriKeyBlob = { + .data = g_mockEcc512PriKeyBlobData, .len = ECC512_PRI_KEY_LEN }; @@ -134,7 +138,7 @@ static const char *GetMockClass(void) return "HcfSymKeyGenerator"; } -static HcfObjectBase obj = { +HcfObjectBase g_obj = { .getClass = GetMockClass, .destroy = NULL }; @@ -270,7 +274,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest104, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - generator->base.destroy(&obj); + generator->base.destroy(&g_obj); HcfObjDestroy(generator); } @@ -313,7 +317,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest107, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&obj); + const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj); ASSERT_EQ(algName, nullptr); @@ -418,7 +422,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest206, TestSize ASSERT_NE(generator, nullptr); HcfKeyPair *keyPair = NULL; - res = generator->generateKeyPair((HcfAsyKeyGenerator *)&obj, NULL, &keyPair); + res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, NULL, &keyPair); ASSERT_EQ(res, HCF_INVALID_PARAMS); ASSERT_EQ(keyPair, nullptr); @@ -504,7 +508,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest304, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(&obj); + keyPair->base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -574,7 +578,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest308, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(&obj); + keyPair->pubKey->base.base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -629,7 +633,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest311, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); @@ -686,7 +690,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest314, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); @@ -761,7 +765,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest317, TestSize .data = NULL, .len = 0 }; - res = keyPair->pubKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); @@ -835,7 +839,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest321, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem((HcfPriKey *)&obj); + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -906,7 +910,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest325, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(&obj); + keyPair->priKey->base.base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -961,7 +965,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest328, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); @@ -1018,7 +1022,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest331, TestSize ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); @@ -1093,7 +1097,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest334, TestSize .data = NULL, .len = 0 }; - res = keyPair->priKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); @@ -1128,7 +1132,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest401, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &outKeyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1143,7 +1147,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest402, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc256PubKeyBlob, &mockEcc256PriKeyBlob, &outKeyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc256PubKeyBlob, &g_mockEcc256PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1158,7 +1162,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest403, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc384PubKeyBlob, &mockEcc384PriKeyBlob, &outKeyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc384PubKeyBlob, &g_mockEcc384PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1173,7 +1177,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest404, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC512", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc512PubKeyBlob, &mockEcc512PriKeyBlob, &outKeyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc512PubKeyBlob, &g_mockEcc512PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1188,7 +1192,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest405, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(NULL, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &outKeyPair); + res = generator->convertKey(NULL, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(outKeyPair, nullptr); @@ -1202,8 +1206,8 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest406, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey((HcfAsyKeyGenerator *)&obj, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, - &outKeyPair); + res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, NULL, + &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(outKeyPair, nullptr); @@ -1217,7 +1221,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest407, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, NULL, &mockEcc224PriKeyBlob, &outKeyPair); + res = generator->convertKey(generator, NULL, NULL, &g_mockEcc224PriKeyBlob, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1232,7 +1236,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest408, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *outKeyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, NULL, &outKeyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, NULL, &outKeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(outKeyPair, nullptr); @@ -1260,7 +1264,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest410, TestSize HcfAsyKeyGenerator *generator = NULL; int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, NULL); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, NULL); ASSERT_NE(res, HCF_SUCCESS); @@ -1273,7 +1277,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest501, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1292,7 +1296,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest502, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1308,7 +1312,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest503, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1325,12 +1329,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest504, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->base.destroy(&obj); + keyPair->base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -1342,7 +1346,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest505, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1360,7 +1364,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest506, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1378,7 +1382,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest507, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1395,12 +1399,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest508, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->pubKey->base.base.destroy(&obj); + keyPair->pubKey->base.base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -1412,7 +1416,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest509, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1431,7 +1435,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest510, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1450,12 +1454,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest511, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); @@ -1469,7 +1473,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest512, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1488,7 +1492,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest513, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1507,12 +1511,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest514, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); @@ -1526,7 +1530,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest515, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1553,7 +1557,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest516, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1578,7 +1582,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest517, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1587,7 +1591,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest517, TestSize .data = NULL, .len = 0 }; - res = keyPair->pubKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); @@ -1603,7 +1607,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest518, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1622,7 +1626,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest519, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1639,7 +1643,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest520, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1656,12 +1660,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest521, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->clearMem((HcfPriKey *)&obj); + keyPair->priKey->clearMem((HcfPriKey *)&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -1673,7 +1677,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest522, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1692,7 +1696,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest523, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1710,7 +1714,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest524, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1727,12 +1731,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest525, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - keyPair->priKey->base.base.destroy(&obj); + keyPair->priKey->base.base.destroy(&g_obj); HcfObjDestroy(keyPair); HcfObjDestroy(generator); @@ -1744,7 +1748,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest526, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1763,7 +1767,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest527, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1782,12 +1786,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest528, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *format = keyPair->priKey->base.getFormat((HcfKey *)&obj); + const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj); ASSERT_EQ(format, nullptr); @@ -1801,7 +1805,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest529, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1820,7 +1824,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest530, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1839,12 +1843,12 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest531, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); - const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&obj); + const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj); ASSERT_EQ(algName, nullptr); @@ -1858,7 +1862,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest532, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1885,7 +1889,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest533, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1910,7 +1914,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest534, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -1919,7 +1923,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest534, TestSize .data = NULL, .len = 0 }; - res = keyPair->priKey->base.getEncoded((HcfKey *)&obj, &blob); + res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(blob.data, nullptr); @@ -1935,7 +1939,7 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest535, TestSize int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); HcfKeyPair *keyPair = NULL; - res = generator->convertKey(generator, NULL, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &keyPair); + res = generator->convertKey(generator, NULL, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(keyPair, nullptr); @@ -2101,4 +2105,313 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize HcfObjDestroy(keyPair); HcfObjDestroy(generator); } + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest601, TestSize.Level0) +{ + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest602, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest603, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_MODE_NONE, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest604, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest605, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfKeyPair *keyPair = nullptr; + res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, nullptr, nullptr, &keyPair); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest606, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest607, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_256, + .primes = HCF_OPENSSL_PRIMES_2, + }; + + HcfAsyKeyGeneratorSpi *spiObj = nullptr; + int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&g_obj); + + HcfObjDestroy(spiObj); +} + +static void MemoryMallocTestFunc(uint32_t mallocCount) +{ + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfAsyKeyGenerator *tmpGenerator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *tmpKeyPair = NULL; + res = tmpGenerator->generateKeyPair(tmpGenerator, NULL, &tmpKeyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPubKeyBlob = { + .data = NULL, + .len = 0 + }; + res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPriKeyBlob = { + .data = NULL, + .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 = NULL; + res = tmpGenerator->convertKey(tmpGenerator, NULL, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair); + free(tmpPubKeyBlob.data); + free(tmpPriKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + if (res == HCF_SUCCESS) { + HcfObjDestroy(tmpOutKeyPair); + } + } +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest701, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = { + .data = NULL, + .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 = NULL, + .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 = NULL; + res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &outKeyPair); + + free(pubKeyBlob.data); + free(priKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + + uint32_t mallocCount = GetMallocNum(); + MemoryMallocTestFunc(mallocCount); + + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount) +{ + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfAsyKeyGenerator *tmpGenerator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *tmpKeyPair = NULL; + res = tmpGenerator->generateKeyPair(tmpGenerator, NULL, &tmpKeyPair); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPubKeyBlob = { + .data = NULL, + .len = 0 + }; + res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob); + if (res != HCF_SUCCESS) { + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + continue; + } + HcfBlob tmpPriKeyBlob = { + .data = NULL, + .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 = NULL; + res = tmpGenerator->convertKey(tmpGenerator, NULL, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair); + free(tmpPubKeyBlob.data); + free(tmpPriKeyBlob.data); + HcfObjDestroy(tmpKeyPair); + HcfObjDestroy(tmpGenerator); + if (res == HCF_SUCCESS) { + HcfObjDestroy(tmpOutKeyPair); + } + } +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest702, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = { + .data = NULL, + .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 = NULL, + .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 = NULL; + res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &outKeyPair); + + free(pubKeyBlob.data); + free(priKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount); + + EndRecordOpensslCallNum(); +} } diff --git a/test/unittest/src/crypto_ecc_key_agreement_test.cpp b/test/unittest/src/crypto_ecc_key_agreement_test.cpp index 3f8b0c849bb101a2f2f5a30e14df5eda62fb0e5f..776fbbf519f37210a5f7342771c78898169b6116 100644 --- a/test/unittest/src/crypto_ecc_key_agreement_test.cpp +++ b/test/unittest/src/crypto_ecc_key_agreement_test.cpp @@ -17,7 +17,11 @@ #include "securec.h" #include "asy_key_generator.h" +#include "ecdh_openssl.h" #include "key_agreement.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" +#include "params_parser.h" using namespace std; using namespace testing::ext; @@ -504,4 +508,241 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest210, TestSize.Level HcfObjDestroy(keyAgreement); } + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest301, TestSize.Level0) +{ + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest302, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest303, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_MODE_NONE, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest304, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&obj, + ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest305, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&obj, ecc256KeyPair_->pubKey, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest306, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, (HcfPubKey *)&obj, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest307, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest308, TestSize.Level0) +{ + HcfKeyAgreementParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + }; + + HcfKeyAgreementSpi *spiObj = nullptr; + int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest401, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfKeyAgreement *keyAgreement = NULL; + int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(keyAgreement); + + uint32_t mallocCount = GetMallocNum(); + + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + keyAgreement = NULL; + res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + if (res != HCF_SUCCESS) { + continue; + } + + out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyAgreement); + continue; + } + + HcfObjDestroy(keyAgreement); + free(out.data); + } + EndRecordMallocNum(); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest402, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfKeyAgreement *keyAgreement = NULL; + int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + ASSERT_EQ(res, HCF_SUCCESS); + + HcfObjDestroy(keyAgreement); + + uint32_t mallocCount = GetOpensslCallNum(); + + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + keyAgreement = NULL; + res = HcfKeyAgreementCreate("ECC256", &keyAgreement); + + if (res != HCF_SUCCESS) { + continue; + } + + out = { + .data = NULL, + .len = 0 + }; + res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out); + + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyAgreement); + continue; + } + + HcfObjDestroy(keyAgreement); + free(out.data); + } + EndRecordOpensslCallNum(); +} } diff --git a/test/unittest/src/crypto_ecc_sign_test.cpp b/test/unittest/src/crypto_ecc_sign_test.cpp index 99ce4a099bbec72bc158ce77bc68508dc9c8e797..b6cc7ea36e5601b67bf73c6f796c2865df0032b4 100644 --- a/test/unittest/src/crypto_ecc_sign_test.cpp +++ b/test/unittest/src/crypto_ecc_sign_test.cpp @@ -18,9 +18,12 @@ #include "asy_key_generator.h" #include "blob.h" +#include "ecdsa_openssl.h" #include "memory.h" #include "securec.h" #include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" using namespace std; using namespace testing::ext; @@ -44,9 +47,9 @@ HcfKeyPair *CryptoEccSignTest::ecc256KeyPair_ = nullptr; HcfKeyPair *CryptoEccSignTest::ecc384KeyPair_ = nullptr; HcfKeyPair *CryptoEccSignTest::ecc512KeyPair_ = nullptr; -static const char *g_mockMessage = "hello world"; -static HcfBlob mockInput = { - .data = (uint8_t *)g_mockMessage, +static const char *MOCK_MESSAGE = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)MOCK_MESSAGE, .len = 12 }; @@ -847,7 +850,11 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest223, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); - res = sign->init(sign, NULL, NULL); + res = sign->init(sign, NULL, ecc256KeyPair_->priKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->init(sign, NULL, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -862,6 +869,21 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest224, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); + res = sign->init(sign, NULL, NULL); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest225, TestSize.Level0) +{ + HcfSign *sign = NULL; + int32_t res = HcfSignCreate("ECC256|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + res = sign->init(sign, NULL, (HcfPriKey *)(&obj)); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -881,7 +903,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest301, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -900,7 +922,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest302, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -919,7 +941,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest303, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -938,7 +960,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest304, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -957,7 +979,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest305, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -976,7 +998,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest306, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -995,7 +1017,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest307, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1014,7 +1036,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest308, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1033,7 +1055,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest309, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1052,7 +1074,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest310, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1071,7 +1093,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest311, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1090,7 +1112,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest312, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1109,7 +1131,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest313, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1128,7 +1150,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest314, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1147,7 +1169,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest315, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1166,7 +1188,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest316, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1185,7 +1207,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest317, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1204,7 +1226,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest318, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1223,7 +1245,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest319, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1242,7 +1264,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest320, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1261,7 +1283,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest321, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(NULL, &mockInput); + res = sign->update(NULL, &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -1280,7 +1302,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest322, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update((HcfSign *)(&obj), &mockInput); + res = sign->update((HcfSign *)(&obj), &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -1295,6 +1317,21 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(sign, nullptr); + res = sign->update(sign, &g_mockInput); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(sign); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0) +{ + HcfSign *sign = NULL; + int32_t res = HcfSignCreate("ECC256|SHA256", &sign); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + res = sign->init(sign, NULL, ecc256KeyPair_->priKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -1306,7 +1343,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0) +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0) { HcfSign *sign = NULL; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); @@ -1329,7 +1366,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0) HcfObjDestroy(sign); } -HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0) +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest326, TestSize.Level0) { HcfSign *sign = NULL; int32_t res = HcfSignCreate("ECC256|SHA256", &sign); @@ -1342,7 +1379,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; res = sign->update(sign, &input); @@ -1364,7 +1401,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest401, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1394,7 +1431,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest402, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1424,7 +1461,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest403, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1454,7 +1491,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest404, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1484,7 +1521,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest405, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1514,7 +1551,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest406, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1544,7 +1581,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest407, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1574,7 +1611,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest408, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1604,7 +1641,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest409, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1634,7 +1671,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest410, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1664,7 +1701,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest411, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1694,7 +1731,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest412, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1724,7 +1761,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest413, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1754,7 +1791,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest414, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1784,7 +1821,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest415, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1814,7 +1851,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest416, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1844,7 +1881,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest417, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1874,7 +1911,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest418, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1904,7 +1941,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest419, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1934,7 +1971,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest420, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1968,7 +2005,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest421, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -1994,7 +2031,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest422, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2020,7 +2057,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest423, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2046,7 +2083,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest424, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2072,7 +2109,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest425, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2098,7 +2135,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest426, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2124,7 +2161,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest427, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2150,7 +2187,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest428, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2176,7 +2213,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest429, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2202,7 +2239,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest430, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2228,7 +2265,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest431, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2254,7 +2291,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest432, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2280,7 +2317,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest433, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2306,7 +2343,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest434, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2332,7 +2369,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest435, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2358,7 +2395,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest436, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2384,7 +2421,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest437, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2410,7 +2447,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest438, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2436,7 +2473,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest439, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2462,7 +2499,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest440, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2484,7 +2521,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest441, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2511,7 +2548,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest442, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2589,7 +2626,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest445, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; HcfBlob out = { @@ -2615,7 +2652,7 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest446, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2813,4 +2850,422 @@ HWTEST_F(CryptoEccSignTest, CryptoEccSignTest928, TestSize.Level0) free(out.data); HcfObjDestroy(sign); } + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1001, TestSize.Level0) +{ + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1002, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1003, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_NOPADDING, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1004, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1005, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1006, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate(nullptr, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1007, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1008, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineUpdate(spiObj, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1009, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1010, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1011, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfSignSpi *spiObj = NULL; + int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfSign *sign = NULL; + res = HcfSignCreate("ECC224|SHA256", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyPair); + continue; + } + res = sign->init(sign, NULL, keyPair->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + res = sign->update(sign, input); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = sign->sign(sign, NULL, &out); + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + if (res == HCF_SUCCESS) { + free(out.data); + } + } +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1101, TestSize.Level0) +{ + StartRecordMallocNum(); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfObjDestroy(generator); + + HcfSign *sign = NULL; + res = HcfSignCreate("ECC224|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfParamsSpec params; + res = sign->init(sign, ¶ms, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = sign->update(sign, &input); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = sign->sign(sign, NULL, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(sign); + + uint32_t mallocCount = GetMallocNum(); + MemoryMallocTestFunc(mallocCount, &input); + + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input) +{ + for (uint32_t i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + HcfObjDestroy(generator); + if (res != HCF_SUCCESS) { + continue; + } + HcfSign *sign = NULL; + res = HcfSignCreate("ECC224|SHA256", &sign); + if (res != HCF_SUCCESS) { + HcfObjDestroy(keyPair); + continue; + } + res = sign->init(sign, NULL, keyPair->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + res = sign->update(sign, input); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + continue; + } + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = sign->sign(sign, input, &out); + HcfObjDestroy(sign); + HcfObjDestroy(keyPair); + if (res == HCF_SUCCESS) { + free(out.data); + } + } +} + +HWTEST_F(CryptoEccSignTest, CryptoEccSignTest1102, TestSize.Level0) +{ + StartRecordOpensslCallNum(); + HcfAsyKeyGenerator *generator = NULL; + int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + HcfKeyPair *keyPair = NULL; + res = generator->generateKeyPair(generator, NULL, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfObjDestroy(generator); + + HcfSign *sign = NULL; + res = HcfSignCreate("ECC224|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + HcfParamsSpec params; + res = sign->init(sign, ¶ms, keyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = sign->update(sign, &input); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { + .data = NULL, + .len = 0 + }; + res = sign->sign(sign, &input, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + free(out.data); + HcfObjDestroy(sign); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount, &input); + + EndRecordOpensslCallNum(); +} } diff --git a/test/unittest/src/crypto_ecc_verify_test.cpp b/test/unittest/src/crypto_ecc_verify_test.cpp index 0c0f2d6e4bddb7b9ce7d305256cedd226fab47ff..66851938f572631302e6e2dd035360036927d18e 100644 --- a/test/unittest/src/crypto_ecc_verify_test.cpp +++ b/test/unittest/src/crypto_ecc_verify_test.cpp @@ -18,9 +18,12 @@ #include "asy_key_generator.h" #include "blob.h" +#include "ecdsa_openssl.h" #include "memory.h" #include "securec.h" #include "signature.h" +#include "memory_mock.h" +#include "openssl_adapter_mock.h" using namespace std; using namespace testing::ext; @@ -44,9 +47,9 @@ HcfKeyPair *CryptoEccVerifyTest::ecc256KeyPair_ = nullptr; HcfKeyPair *CryptoEccVerifyTest::ecc384KeyPair_ = nullptr; HcfKeyPair *CryptoEccVerifyTest::ecc512KeyPair_ = nullptr; -static const char *g_mockMessage = "hello world"; -static HcfBlob mockInput = { - .data = (uint8_t *)g_mockMessage, +static const char *MOCK_MESSAGE = "hello world"; +static HcfBlob g_mockInput = { + .data = (uint8_t *)MOCK_MESSAGE, .len = 12 }; @@ -847,7 +850,11 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest223, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); - res = verify->init(verify, NULL, NULL); + res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -862,6 +869,21 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest224, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); + res = verify->init(verify, NULL, NULL); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest225, TestSize.Level0) +{ + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + res = verify->init(verify, NULL, (HcfPubKey *)(&obj)); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -881,7 +903,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest301, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -900,7 +922,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest302, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -919,7 +941,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest303, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -938,7 +960,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest304, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -957,7 +979,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest305, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -976,7 +998,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest306, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -995,7 +1017,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest307, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1014,7 +1036,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest308, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1033,7 +1055,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest309, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1052,7 +1074,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest310, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1071,7 +1093,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest311, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1090,7 +1112,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest312, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1109,7 +1131,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest313, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1128,7 +1150,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest314, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1147,7 +1169,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest315, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1166,7 +1188,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest316, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1185,7 +1207,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest317, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1204,7 +1226,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest318, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1223,7 +1245,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest319, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1242,7 +1264,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest320, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1261,7 +1283,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest321, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(NULL, &mockInput); + res = verify->update(NULL, &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -1280,7 +1302,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest322, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update((HcfVerify *)(&obj), &mockInput); + res = verify->update((HcfVerify *)(&obj), &g_mockInput); ASSERT_EQ(res, HCF_INVALID_PARAMS); @@ -1295,6 +1317,21 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest323, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(verify, nullptr); + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(verify); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0) +{ + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + res = verify->init(verify, NULL, ecc256KeyPair_->pubKey); ASSERT_EQ(res, HCF_SUCCESS); @@ -1306,7 +1343,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest323, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0) +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0) { HcfVerify *verify = NULL; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); @@ -1329,7 +1366,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0) HcfObjDestroy(verify); } -HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0) +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest326, TestSize.Level0) { HcfVerify *verify = NULL; int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify); @@ -1342,7 +1379,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; res = verify->update(verify, &input); @@ -1364,7 +1401,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest401, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1388,7 +1425,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest401, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1413,7 +1450,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest402, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1437,7 +1474,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest402, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1462,7 +1499,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest403, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1486,7 +1523,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest403, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1511,7 +1548,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest404, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1535,7 +1572,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest404, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1560,7 +1597,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest405, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1584,7 +1621,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest405, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1609,7 +1646,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest406, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1633,7 +1670,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest406, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1658,7 +1695,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest407, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1682,7 +1719,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest407, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1707,7 +1744,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest408, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1731,7 +1768,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest408, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1756,7 +1793,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest409, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1780,7 +1817,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest409, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1805,7 +1842,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest410, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1829,7 +1866,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest410, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1854,7 +1891,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1878,7 +1915,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1903,7 +1940,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1927,7 +1964,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1952,7 +1989,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -1976,7 +2013,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2001,7 +2038,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest414, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2025,7 +2062,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest414, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2050,7 +2087,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest415, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2074,7 +2111,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest415, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2099,7 +2136,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest416, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2123,7 +2160,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest416, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2148,7 +2185,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest417, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2172,7 +2209,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest417, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2197,7 +2234,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest418, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2221,7 +2258,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest418, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2246,7 +2283,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest419, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2270,7 +2307,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest419, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2295,7 +2332,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest420, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2319,7 +2356,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest420, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -2348,7 +2385,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest421, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2364,7 +2401,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest421, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2389,7 +2426,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest422, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2405,7 +2442,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest422, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2430,7 +2467,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest423, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2446,7 +2483,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest423, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2471,7 +2508,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest424, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2487,7 +2524,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest424, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2512,7 +2549,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest425, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2528,7 +2565,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest425, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2553,7 +2590,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest426, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2569,7 +2606,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest426, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2594,7 +2631,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest427, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2610,7 +2647,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest427, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2635,7 +2672,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest428, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2651,7 +2688,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest428, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2676,7 +2713,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest429, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2692,7 +2729,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest429, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2717,7 +2754,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest430, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2733,7 +2770,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest430, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2758,7 +2795,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest431, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2774,7 +2811,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest431, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2799,7 +2836,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest432, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2815,7 +2852,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest432, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2840,7 +2877,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest433, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2856,7 +2893,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest433, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2881,7 +2918,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest434, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2897,7 +2934,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest434, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2922,7 +2959,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest435, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2938,7 +2975,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest435, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -2963,7 +3000,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest436, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -2979,7 +3016,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest436, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -3004,7 +3041,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest437, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -3020,7 +3057,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest437, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -3045,7 +3082,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest438, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -3061,7 +3098,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest438, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -3086,7 +3123,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest439, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -3102,7 +3139,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest439, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -3127,7 +3164,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest440, TestSize.Level0) .data = NULL, .len = 0 }; - res = sign->sign(sign, &mockInput, &out); + res = sign->sign(sign, &g_mockInput, &out); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(out.data, nullptr); @@ -3143,7 +3180,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest440, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - bool flag = verify->verify(verify, &mockInput, &out); + bool flag = verify->verify(verify, &g_mockInput, &out); ASSERT_EQ(flag, true); @@ -3164,7 +3201,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest441, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3188,7 +3225,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest441, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3213,7 +3250,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest442, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3237,7 +3274,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest442, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3262,7 +3299,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest443, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3307,7 +3344,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest444, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3356,7 +3393,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest445, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = sign->update(sign, &mockInput); + res = sign->update(sign, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3381,7 +3418,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest445, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); HcfBlob input = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; bool flag = verify->verify(verify, &input, &out); @@ -3405,7 +3442,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest446, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3428,7 +3465,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest447, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); @@ -3455,12 +3492,12 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest448, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); - res = verify->update(verify, &mockInput); + res = verify->update(verify, &g_mockInput); ASSERT_EQ(res, HCF_SUCCESS); HcfBlob mockOut = { - .data = (uint8_t *)g_mockMessage, + .data = (uint8_t *)MOCK_MESSAGE, .len = 0 }; bool flag = verify->verify(verify, NULL, &mockOut); @@ -3469,4 +3506,392 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest448, TestSize.Level0) HcfObjDestroy(verify); } + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest501, TestSize.Level0) +{ + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(nullptr, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest502, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, nullptr); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest503, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_NOPADDING, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_INVALID_PARAMS); + ASSERT_EQ(spiObj, nullptr); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest504, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, ecc256KeyPair_->pubKey); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest505, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineInit(spiObj, nullptr, (HcfPubKey *)&obj); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest506, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate(nullptr, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest507, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + res = spiObj->engineUpdate((HcfVerifySpi *)&obj, &input); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest508, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + res = spiObj->engineUpdate(spiObj, nullptr); + ASSERT_EQ(res, HCF_INVALID_PARAMS); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest509, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + HcfBlob out = { + .data = NULL, + .len = 0 + }; + bool isOk = spiObj->engineVerify(nullptr, &input, &out); + ASSERT_EQ(isOk, false); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest510, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + const char *message = "hello world"; + HcfBlob input = { + .data = (uint8_t *)message, + .len = 12 + }; + bool isOk = spiObj->engineVerify((HcfVerifySpi *)&obj, &input, &input); + ASSERT_EQ(isOk, false); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest511, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(nullptr); + + HcfObjDestroy(spiObj); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest512, TestSize.Level0) +{ + HcfSignatureParams params = { + .algo = HCF_ALG_ECC, + .keyLen = HCF_ALG_ECC_256, + .padding = HCF_ALG_NOPADDING, + .md = HCF_OPENSSL_DIGEST_SHA256, + .mgf1md = HCF_OPENSSL_DIGEST_SHA256, + }; + HcfVerifySpi *spiObj = NULL; + int32_t res = HcfVerifySpiEcdsaCreate(¶ms, &spiObj); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(spiObj, nullptr); + + spiObj->base.destroy(&obj); + + HcfObjDestroy(spiObj); +} + +static bool GetSignTestData(HcfBlob *out) +{ + HcfSign *sign = NULL; + int32_t res = HcfSignCreate("ECC224|SHA224", &sign); + if (res != HCF_SUCCESS) { + return false; + } + res = sign->init(sign, NULL, CryptoEccVerifyTest::ecc224KeyPair_->priKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + return false; + } + res = sign->update(sign, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(sign); + return false; + } + res = sign->sign(sign, &g_mockInput, out); + HcfObjDestroy(sign); + return res == HCF_SUCCESS; +} + +static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out) +{ + for (int i = 0; i < mallocCount; i++) { + ResetRecordMallocNum(); + SetMockMallocIndex(i); + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, NULL, CryptoEccVerifyTest::ecc224KeyPair_->pubKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + res = verify->update(verify, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + (void)verify->verify(verify, NULL, out); + HcfObjDestroy(verify); + } +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest601, TestSize.Level0) +{ + HcfBlob out = { + .data = NULL, + .len = 0 + }; + GetSignTestData(&out); + StartRecordMallocNum(); + + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetMallocNum(); + MemoryMockTestFunc(mallocCount, &out); + EndRecordMallocNum(); +} + +static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out) +{ + for (int i = 0; i < mallocCount; i++) { + ResetOpensslCallNum(); + SetOpensslCallMockIndex(i); + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + if (res != HCF_SUCCESS) { + continue; + } + res = verify->init(verify, NULL, CryptoEccVerifyTest::ecc224KeyPair_->pubKey); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + res = verify->update(verify, &g_mockInput); + if (res != HCF_SUCCESS) { + HcfObjDestroy(verify); + continue; + } + (void)verify->verify(verify, &g_mockInput, out); + HcfObjDestroy(verify); + } +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest602, TestSize.Level0) +{ + HcfBlob out = { + .data = NULL, + .len = 0 + }; + ASSERT_EQ(GetSignTestData(&out), true); + StartRecordOpensslCallNum(); + + HcfVerify *verify = NULL; + int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, NULL, ecc224KeyPair_->pubKey); + + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, &g_mockInput, &out); + + ASSERT_EQ(flag, true); + HcfObjDestroy(verify); + + uint32_t mallocCount = GetOpensslCallNum(); + OpensslMockTestFunc(mallocCount, &out); + EndRecordOpensslCallNum(); +} } diff --git a/test/unittest/src/memory_mock.c b/test/unittest/src/memory_mock.c index d998a92eed7bdc09201f379732ab3a51d8782f4e..35f7b2c6c6ec1cd20e143066c3bc11ca86dc141c 100755 --- a/test/unittest/src/memory_mock.c +++ b/test/unittest/src/memory_mock.c @@ -20,6 +20,9 @@ #include "securec.h" static bool g_isMock = false; +static uint32_t g_mallocMockIndex = __INT32_MAX__; +static uint32_t g_mallocNum = 0; +static bool g_isRecordMallocNum = false; void SetMockFlag(bool flag) { @@ -31,6 +34,13 @@ void *HcfMalloc(uint32_t size, char val) if (g_isMock) { return NULL; } + if (g_isRecordMallocNum) { + if (g_mallocNum == g_mallocMockIndex) { + LOGI("mock malloc return NULL."); + return NULL; + } + g_mallocNum++; + } void *addr = malloc(size); if (addr != NULL) { (void)memset_s(addr, size, val, size); @@ -44,3 +54,31 @@ void HcfFree(void *addr) free(addr); } } + +void StartRecordMallocNum(void) +{ + ResetRecordMallocNum(); + g_isRecordMallocNum = true; +} + +void EndRecordMallocNum(void) +{ + ResetRecordMallocNum(); + g_isRecordMallocNum = false; +} + +uint32_t GetMallocNum(void) +{ + return g_mallocNum; +} + +void ResetRecordMallocNum(void) +{ + g_mallocNum = 0; + g_mallocMockIndex = __INT32_MAX__; +} + +void SetMockMallocIndex(uint32_t index) +{ + g_mallocMockIndex = index; +} \ No newline at end of file diff --git a/test/unittest/src/openssl_adapter_mock.c b/test/unittest/src/openssl_adapter_mock.c new file mode 100644 index 0000000000000000000000000000000000000000..e813a9d42a714b04910aa8208e9d2fc39c28fef8 --- /dev/null +++ b/test/unittest/src/openssl_adapter_mock.c @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_adapter.h" +#include "openssl_adapter_mock.h" + +#include "log.h" +#include "result.h" + +static uint32_t g_mockIndex = __INT32_MAX__; +static uint32_t g_callNum = 0; +static bool g_isRecordCallNum = false; +static bool g_isNeedSpecialMock = false; + +static bool Is_Need_Mock(void) +{ + if (!g_isRecordCallNum) { + return false; + } + g_callNum++; + if (g_callNum == g_mockIndex) { + LOGI("mock malloc return NULL."); + return true; + } + return false; +} + +void StartRecordOpensslCallNum(void) +{ + ResetOpensslCallNum(); + g_isRecordCallNum = true; +} + +void EndRecordOpensslCallNum(void) +{ + ResetOpensslCallNum(); + g_isRecordCallNum = false; +} + +uint32_t GetOpensslCallNum(void) +{ + return g_callNum; +} + +void ResetOpensslCallNum(void) +{ + g_callNum = 0; + g_mockIndex = __INT32_MAX__; +} + +void SetOpensslCallMockIndex(uint32_t index) +{ + g_mockIndex = index; +} + +BIGNUM *Openssl_BN_dup(const BIGNUM *a) +{ + if (Is_Need_Mock()) { + return NULL; + } + return BN_dup(a); +} + +void Openssl_BN_clear(BIGNUM *a) +{ + BN_clear(a); +} + +void Openssl_BN_clear_free(BIGNUM *a) +{ + BN_clear_free(a); +} + +EC_KEY *Openssl_EC_KEY_new_by_curve_name(int nid) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_new_by_curve_name(nid); +} + +EC_POINT *Openssl_EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_POINT_dup(src, group); +} + +int Openssl_EC_KEY_generate_key(EC_KEY *eckey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_generate_key(eckey); +} + +int Openssl_EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_set_public_key(key, pub); +} + +int Openssl_EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_set_private_key(key, priv_key); +} + +int Openssl_EC_KEY_check_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EC_KEY_check_key(key); +} + +const EC_POINT *Openssl_EC_KEY_get0_public_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_public_key(key); +} + +const BIGNUM *Openssl_EC_KEY_get0_private_key(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_private_key(key); +} + +const EC_GROUP *Openssl_EC_KEY_get0_group(const EC_KEY *key) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EC_KEY_get0_group(key); +} + +int Openssl_i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp) +{ + if (Is_Need_Mock()) { + return -1; + } + return i2d_EC_PUBKEY(a, pp); +} + +int Openssl_i2d_ECPrivateKey(EC_KEY *key, unsigned char **out) +{ + if (Is_Need_Mock()) { + return -1; + } + return i2d_ECPrivateKey(key, out); +} + +EC_KEY *Openssl_d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) +{ + if (Is_Need_Mock()) { + return NULL; + } + return d2i_EC_PUBKEY(a, pp, length); +} + +EC_KEY *Openssl_d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len) +{ + if (Is_Need_Mock()) { + return NULL; + } + return d2i_ECPrivateKey(key, in, len); +} + +void Openssl_EC_KEY_set_asn1_flag(EC_KEY *key, int flag) +{ + EC_KEY_set_asn1_flag(key, flag); +} + +void Openssl_EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags) +{ + EC_KEY_set_enc_flags(eckey, flags); +} + +void Openssl_EC_KEY_free(EC_KEY *key) +{ + EC_KEY_free(key); +} + +void Openssl_EC_POINT_free(EC_POINT *point) +{ + EC_POINT_free(point); +} + +EVP_MD_CTX *Openssl_EVP_MD_CTX_new(void) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_MD_CTX_new(); +} + +void Openssl_EVP_MD_CTX_free(EVP_MD_CTX *ctx) +{ + EVP_MD_CTX_free(ctx); +} + +int Openssl_EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestSignInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestSignUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen) +{ + if (sigret != NULL && g_isNeedSpecialMock) { + g_callNum++; + } + if (Is_Need_Mock()) { + if (sigret == NULL) { + return -1; + } + if (g_isNeedSpecialMock) { + int res = EVP_DigestSignFinal(ctx, sigret, siglen); + *siglen = *siglen * 2; + g_isNeedSpecialMock = false; + return res; + } + g_isNeedSpecialMock = true; + return -1; + } + if (sigret != NULL) { + g_callNum++; + } + return EVP_DigestSignFinal(ctx, sigret, siglen); +} + +int Openssl_EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyInit(ctx, pctx, type, e, pkey); +} + +int Openssl_EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t count) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyUpdate(ctx, data, count); +} + +int Openssl_EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_DigestVerifyFinal(ctx, sig, siglen); +} + +EVP_PKEY *Openssl_EVP_PKEY_new(void) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_PKEY_new(); +} + +int Openssl_EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_assign_EC_KEY(pkey, key); +} + +void Openssl_EVP_PKEY_free(EVP_PKEY *pkey) +{ + EVP_PKEY_free(pkey); +} + +EVP_PKEY_CTX *Openssl_EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) +{ + if (Is_Need_Mock()) { + return NULL; + } + return EVP_PKEY_CTX_new(pkey, e); +} + +int Openssl_EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_derive_init(ctx); +} + +int Openssl_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer) +{ + if (Is_Need_Mock()) { + return -1; + } + return EVP_PKEY_derive_set_peer(ctx, peer); +} + +int Openssl_EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen) +{ + if (key != NULL && g_isNeedSpecialMock) { + g_callNum++; + } + if (Is_Need_Mock()) { + if (key == NULL) { + return -1; + } + if (g_isNeedSpecialMock) { + int res = EVP_PKEY_derive(ctx, key, keylen); + *keylen = *keylen * 2; + g_isNeedSpecialMock = false; + return res; + } + g_isNeedSpecialMock = true; + return -1; + } + if (key != NULL) { + g_callNum++; + } + return EVP_PKEY_derive(ctx, key, keylen); +} + +void Openssl_EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) +{ + EVP_PKEY_CTX_free(ctx); +}