From f8921edb2e3392b87bbff5c9e03841487ae80e17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Wed, 23 Oct 2024 11:12:41 +0800 Subject: [PATCH 1/3] =?UTF-8?q?EC=E5=AF=86=E9=92=A5=E8=A7=84=E6=A0=BC?= =?UTF-8?q?=E6=96=B0=E5=A2=9Esecp256k1=E6=9B=B2=E7=BA=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 王静 --- common/inc/params_parser.h | 2 + common/src/params_parser.c | 4 +- frameworks/crypto_operation/key_agreement.c | 1 + frameworks/crypto_operation/signature.c | 1 + .../js/napi/crypto/src/napi_key_agreement.cpp | 2 +- frameworks/key/asy_key_generator.c | 1 + .../inc/ecc_openssl_common_param_spec.h | 26 +++++ .../common/inc/openssl_common.h | 2 + .../common/src/ecc_openssl_common.c | 8 ++ .../common/src/openssl_common.c | 24 +++- .../src/ecc_asy_key_generator_openssl.c | 28 +++++ .../ecc_common_param_spec_generator_openssl.c | 18 ++- .../src/crypto_ecc_asy_key_generator_test.cpp | 68 +++++++++++ .../src/crypto_ecc_key_agreement_test.cpp | 85 ++++++++++++++ .../src/ecc/crypto_ecc_verify_test.cpp | 107 ++++++++++++++++++ 15 files changed, 368 insertions(+), 9 deletions(-) diff --git a/common/inc/params_parser.h b/common/inc/params_parser.h index 6e333c6..5eece2a 100644 --- a/common/inc/params_parser.h +++ b/common/inc/params_parser.h @@ -152,6 +152,8 @@ typedef enum { HCF_ALG_ECC_BP512R1, HCF_ALG_ECC_BP512T1, + HCF_ALG_ECC_SECP256K1, + // ed25519 HCF_ALG_ED25519_256, HCF_ALG_X25519_256, diff --git a/common/src/params_parser.c b/common/src/params_parser.c index 68b3569..5ddb8c2 100644 --- a/common/src/params_parser.c +++ b/common/src/params_parser.c @@ -135,6 +135,7 @@ static const HcfParaConfig PARAM_CONFIG[] = { {"ECC_BrainPoolP384t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP384T1}, {"ECC_BrainPoolP512r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512R1}, {"ECC_BrainPoolP512t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512T1}, + {"ECC_Secp256k1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_SECP256K1}, {"Ed25519", HCF_ALG_KEY_TYPE, HCF_ALG_ED25519_256}, {"X25519", HCF_ALG_KEY_TYPE, HCF_ALG_X25519_256}, @@ -172,7 +173,8 @@ static const HcfCurveMap CURVE_MAP[] = { {"NID_brainpoolP384r1", HCF_ALG_ECC_BP384R1}, {"NID_brainpoolP384t1", HCF_ALG_ECC_BP384T1}, {"NID_brainpoolP512r1", HCF_ALG_ECC_BP512R1}, - {"NID_brainpoolP512t1", HCF_ALG_ECC_BP512T1} + {"NID_brainpoolP512t1", HCF_ALG_ECC_BP512T1}, + {"NID_secp256k1", HCF_ALG_ECC_SECP256K1} }; static const HcfFormatMap FORMAT_MAP[] = { diff --git a/frameworks/crypto_operation/key_agreement.c b/frameworks/crypto_operation/key_agreement.c index 76987d7..45e6598 100644 --- a/frameworks/crypto_operation/key_agreement.c +++ b/frameworks/crypto_operation/key_agreement.c @@ -81,6 +81,7 @@ static void SetKeyType(HcfAlgParaValue value, HcfKeyAgreementParams *paramsObj) case HCF_ALG_ECC_BP384T1: case HCF_ALG_ECC_BP512R1: case HCF_ALG_ECC_BP512T1: + case HCF_ALG_ECC_SECP256K1: paramsObj->algo = HCF_ALG_ECC; break; case HCF_ALG_X25519_256: diff --git a/frameworks/crypto_operation/signature.c b/frameworks/crypto_operation/signature.c index 74c220c..7867c92 100644 --- a/frameworks/crypto_operation/signature.c +++ b/frameworks/crypto_operation/signature.c @@ -141,6 +141,7 @@ static void SetKeyType(HcfAlgParaValue value, HcfSignatureParams *paramsObj) case HCF_ALG_ECC_256: case HCF_ALG_ECC_384: case HCF_ALG_ECC_521: + case HCF_ALG_ECC_SECP256K1: paramsObj->algo = HCF_ALG_ECC; break; case HCF_ALG_ECC_BP160R1: diff --git a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp index 0e6ff2d..aa9ab98 100644 --- a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp +++ b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp @@ -341,7 +341,7 @@ napi_value NapiKeyAgreement::JsGenerateSecretSync(napi_env env, napi_callback_in HcfBlob returnSecret = { .data = nullptr, .len = 0 }; ret = keyAgreement->generateSecret(keyAgreement, priKey, pubKey, &returnSecret); if (ret != HCF_SUCCESS) { - LOGD("generate secret fail."); + LOGE("generate secret fail."); napi_throw(env, GenerateBusinessError(env, ret, "generate secret fail.")); return nullptr; } diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index 479af45..28f23fc 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -117,6 +117,7 @@ static const KeyTypeAlg KEY_TYPE_MAP[] = { { HCF_ALG_ECC_BP384T1, HCF_ALG_ECC_BP384T1, HCF_ALG_ECC }, { HCF_ALG_ECC_BP512R1, HCF_ALG_ECC_BP512R1, HCF_ALG_ECC }, { HCF_ALG_ECC_BP512T1, HCF_ALG_ECC_BP512T1, HCF_ALG_ECC }, + { HCF_ALG_ECC_SECP256K1, HCF_ALG_ECC_SECP256K1, HCF_ALG_ECC }, { HCF_ALG_ED25519_256, HCF_ALG_ED25519_256, HCF_ALG_ED25519 }, { HCF_ALG_X25519_256, HCF_ALG_X25519_256, HCF_ALG_X25519 }, { HCF_OPENSSL_DH_MODP_1536, HCF_DH_MODP_SIZE_1536, HCF_ALG_DH }, diff --git a/plugin/openssl_plugin/common/inc/ecc_openssl_common_param_spec.h b/plugin/openssl_plugin/common/inc/ecc_openssl_common_param_spec.h index 6a9b217..877fa3e 100644 --- a/plugin/openssl_plugin/common/inc/ecc_openssl_common_param_spec.h +++ b/plugin/openssl_plugin/common/inc/ecc_openssl_common_param_spec.h @@ -36,6 +36,7 @@ static const int32_t NID_brainpoolP384r1_len = 48; static const int32_t NID_brainpoolP384t1_len = 48; static const int32_t NID_brainpoolP512r1_len = 64; static const int32_t NID_brainpoolP512t1_len = 64; +static const int32_t NID_secp256k1_len = 32; static unsigned char g_ecc224CorrectBigP[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, @@ -361,6 +362,31 @@ static unsigned char g_bp256t1CorrectBigGY[] = { 0x1D, 0xAB, 0xE8, 0xF3, 0x5B, 0x25, 0xC9, 0xBE }; +//secp256k1 +static unsigned char g_secp256k1CorrectBigP[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFC, 0x2F +}; + +static unsigned char g_secp256k1CorrectBigB[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07 +}; + +static unsigned char g_secp256k1CorrectBigGX[] = { + 0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC, 0x55, 0xA0, 0x62, 0x95, + 0xCE, 0x87, 0x0B, 0x07, 0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE, 0x28, 0xD9, + 0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17, 0x98 +}; + +static unsigned char g_secp256k1CorrectBigGY[] = { + 0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, + 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, + 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8 +}; + // BrainPool320r1 static unsigned char g_bp320r1CorrectBigP[] = { 0xD3, 0x5E, 0x47, 0x20, 0x36, 0xBC, 0x4F, 0xB7, 0xE1, 0x3C, 0x78, 0x5E, diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index ae4c4b7..06930e7 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -58,6 +58,8 @@ HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest); HcfResult BigNumToBigInteger(const BIGNUM *src, HcfBigInteger *dest); +HcfResult BigNumToBigIntegerSecp256k1(const BIGNUM *src, HcfBigInteger *dest); + HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString); HcfResult GetRsaSpecStringMGF(char **returnString); diff --git a/plugin/openssl_plugin/common/src/ecc_openssl_common.c b/plugin/openssl_plugin/common/src/ecc_openssl_common.c index 4afd54a..3711721 100644 --- a/plugin/openssl_plugin/common/src/ecc_openssl_common.c +++ b/plugin/openssl_plugin/common/src/ecc_openssl_common.c @@ -309,6 +309,14 @@ HcfResult GetCurveGFp(const EC_GROUP *group, const AsyKeySpecItem item, HcfBigIn } HcfResult ret = HCF_INVALID_PARAMS; + int curveId = OpensslEcGroupGetCurveName(group); + if (curveId == NID_secp256k1 && item == ECC_A_BN) { + ret = BigNumToBigIntegerSecp256k1(a, returnBigInteger); + OpensslBnFree(p); + OpensslBnFree(a); + OpensslBnFree(b); + return ret; + } switch (item) { case ECC_FP_P_BN: ret = BigNumToBigInteger(p, returnBigInteger); diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index bbe8ac2..2be46e0 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -65,6 +65,7 @@ static const NidTypeAlg NID_TYPE_MAP[] = { { HCF_ALG_ECC_BP384T1, NID_brainpoolP384t1, "brainpoolP384t1" }, { HCF_ALG_ECC_BP512R1, NID_brainpoolP512r1, "brainpoolP512r1" }, { HCF_ALG_ECC_BP512T1, NID_brainpoolP512t1, "brainpoolP512t1" }, + { HCF_ALG_ECC_SECP256K1, NID_secp256k1, "secp256k1" }, }; typedef struct { @@ -90,7 +91,8 @@ static const CurveNameAlg CURVE_NAME_MAP[] = { { NID_brainpoolP384r1, "NID_brainpoolP384r1" }, { NID_brainpoolP384t1, "NID_brainpoolP384t1" }, { NID_brainpoolP512r1, "NID_brainpoolP512r1" }, - { NID_brainpoolP512t1, "NID_brainpoolP512t1" } + { NID_brainpoolP512t1, "NID_brainpoolP512t1" }, + { NID_secp256k1, "NID_secp256k1" } }; typedef struct { @@ -117,7 +119,8 @@ static const AlgNameType ALG_NAME_TYPE_MAP[] = { { HCF_ALG_ECC_BP384R1, "ECC" }, { HCF_ALG_ECC_BP384T1, "ECC" }, { HCF_ALG_ECC_BP512R1, "ECC" }, - { HCF_ALG_ECC_BP512T1, "ECC" } + { HCF_ALG_ECC_BP512T1, "ECC" }, + { HCF_ALG_ECC_SECP256K1, "ECC" } }; typedef struct { @@ -445,6 +448,23 @@ HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest) return HCF_SUCCESS; } +HcfResult BigNumToBigIntegerSecp256k1(const BIGNUM *src, HcfBigInteger *dest) +{ + if (src == NULL || dest == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + int len = 1; + dest->data = (unsigned char *)HcfMalloc(len, 0); + if (dest->data == NULL) { + LOGE("Alloc dest->data memeory failed."); + return HCF_ERR_MALLOC; + } + dest->len = len; + dest->data[0] = 0; + return HCF_SUCCESS; +} + HcfResult BigNumToBigInteger(const BIGNUM *src, HcfBigInteger *dest) { if (src == NULL || dest == NULL) { 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 ea7e811..25bea46 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 @@ -355,6 +355,30 @@ static HcfResult CheckBP256t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) return HCF_INVALID_PARAMS; } +static HcfResult CheckSecp256k1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) +{ + BIGNUM *pStd = NULL; + BIGNUM *bStd = NULL; + BIGNUM *xStd = NULL; + BIGNUM *yStd = NULL; + pStd = OpensslBin2Bn(g_secp256k1CorrectBigP, NID_secp256k1_len, NULL); + bStd = OpensslBin2Bn(g_secp256k1CorrectBigB, NID_secp256k1_len, NULL); + xStd = OpensslBin2Bn(g_secp256k1CorrectBigGX, NID_secp256k1_len, NULL); + yStd = OpensslBin2Bn(g_secp256k1CorrectBigGY, NID_secp256k1_len, NULL); + if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { + LOGD("[error] Secp256k1 Curve convert to BN fail"); + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_ERR_CRYPTO_OPERATION; + } + if (OpensslBnCmp(p, pStd) == 0 && OpensslBnCmp(b, bStd) == 0 && + OpensslBnCmp(x, xStd) == 0 && OpensslBnCmp(y, yStd) == 0) { + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_SUCCESS; + } + FreeCurveBigNum(pStd, bStd, xStd, yStd); + return HCF_INVALID_PARAMS; +} + static HcfResult CheckBP320r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { BIGNUM *pStd = NULL; @@ -565,6 +589,10 @@ static HcfResult CompareOpenssl256BitsType(const HcfEccCommParamsSpec *ecParams, bigIntegerParams->y) == HCF_SUCCESS) { *curveId = NID_brainpoolP256t1; return HCF_SUCCESS; + } else if (CheckSecp256k1CurveId(bigIntegerParams->p, bigIntegerParams->b, bigIntegerParams->x, + bigIntegerParams->y) == HCF_SUCCESS) { + *curveId = NID_secp256k1; + return HCF_SUCCESS; } return HCF_NOT_SUPPORT; } diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c index 97df1dd..e7c6e35 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c @@ -120,12 +120,20 @@ static HcfResult BuildCommonParamGFp(const EC_GROUP *ecGroup, HcfEccCommParamsSp return HCF_ERR_CRYPTO_OPERATION; } HcfResult ret = HCF_SUCCESS; - + int curveId = OpensslEcGroupGetCurveName(ecGroup); do { - if (BigNumToBigInteger(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { - LOGE("Build commonParamSpec a failed."); - ret = HCF_ERR_CRYPTO_OPERATION; - break; + if (curveId == NID_secp256k1) { + if (BigNumToBigIntegerSecp256k1(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { + LOGE("Build Secp256k1CommonParamSpec a failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + } else { + if (BigNumToBigInteger(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { + LOGE("Build commonParamSpec a failed."); + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } } if (BigNumToBigInteger(b, &(returnCommonParamSpec->paramsSpec.b)) != HCF_SUCCESS) { LOGE("Build commonParamSpec b failed."); 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 068c8c8..984f224 100644 --- a/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_ecc_asy_key_generator_test.cpp @@ -2391,4 +2391,72 @@ HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccPrvKeyDerConvertTest801, TestSiz EndRecordMallocNum(); } +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest901, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); + + HcfKeyPair *keyPair = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair, nullptr); + + HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 }; + res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob priKeyBlob = { .data = nullptr, .len = 0 }; + res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfKeyPair *outKeyPair = nullptr; + res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outKeyPair, nullptr); + + HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPubKeyBlob.data, nullptr); + ASSERT_NE(outPubKeyBlob.len, 0); + + HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 }; + res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(outPriKeyBlob.data, nullptr); + ASSERT_NE(outPriKeyBlob.len, 0); + + HcfFree(pubKeyBlob.data); + HcfFree(priKeyBlob.data); + HcfFree(outPubKeyBlob.data); + HcfFree(outPriKeyBlob.data); + HcfObjDestroy(outKeyPair); + HcfObjDestroy(keyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest902, TestSize.Level0) +{ + HcfAsyKeyGenParams params = { + .algo = HCF_ALG_ECC, + .bits = HCF_ALG_ECC_SECP256K1, + .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); +} + +HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest903, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_secp256k1", &generator); + ASSERT_NE(res, HCF_SUCCESS); + ASSERT_EQ(generator, nullptr); +} } diff --git a/test/unittest/src/crypto_ecc_key_agreement_test.cpp b/test/unittest/src/crypto_ecc_key_agreement_test.cpp index a704a44..51df04d 100644 --- a/test/unittest/src/crypto_ecc_key_agreement_test.cpp +++ b/test/unittest/src/crypto_ecc_key_agreement_test.cpp @@ -28,6 +28,22 @@ using namespace std; using namespace testing::ext; +static string g_testEccSecp256k1PriKey = "-----BEGIN PRIVATE KEY-----\n" +"MIGEAgEAMBAGByqGSM49AgEGBSuBBAAKBG0wawIBAQQgHCRzy0IcEx6CeA6ogNNK\n" +"SOfuTlHy4fE/LNxkANUS4k+hRANCAASDBmwKklX4OcbZSJJX9mxm1Wr7TPTLpbyp\n" +"xKcKRm0XKNxVlrZU8WQCl66GtX2DDyX+0+XiC3hbaRWcYtg7P6WO\n" +"-----END PRIVATE KEY-----\n"; + +static string g_testEccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n" +"MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEBUKCHJHsvlcod0MCVlFHylzW241nveMm\n" +"RAFhryNgX6rVqooGReVUm+WiF7Uz0ZsIjdHKd9HHe+2BOWfnuWyR1A==\n" +"-----END PUBLIC KEY-----\n"; + +static uint8_t SharedSecret[] = {0xaf, 0x43, 0xb5, 0x27, 0x90, 0x08, 0x2f, 0xd8, + 0x7a, 0xfb, 0x1d, 0x14, 0xb8, 0x83, 0xc1, 0x2d, + 0x12, 0xbb, 0x9e, 0x55, 0x40, 0x80, 0xd1, 0xf8, + 0xe5, 0x27, 0x92, 0x06, 0x76, 0xe3, 0x1f, 0x3e}; + namespace { class CryptoEccKeyAgreementTest : public testing::Test { public: @@ -729,4 +745,73 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccCommonTest01, TestSize.Level0) HcfResult ret = GenerateEcGroupWithParamsSpec(nullptr, nullptr); EXPECT_EQ(ret, HCF_INVALID_PARAMS); } + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest403, TestSize.Level0) +{ + HcfKeyAgreement *keyAgreement = nullptr; + int32_t res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement); + + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + HcfBlob out = { .data = nullptr, .len = 0 }; + HcfKeyPair *eccSecp256k1KeyPair = nullptr; + HcfAsyKeyGenerator *generator = nullptr; + res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->convertPemKey(generator, nullptr, g_testEccSecp256k1PubKey.c_str(), + g_testEccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(eccSecp256k1KeyPair, nullptr); + + res = keyAgreement->generateSecret(keyAgreement, eccSecp256k1KeyPair->priKey, eccSecp256k1KeyPair->pubKey, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_EQ(out.len, sizeof(SharedSecret)); + for (int i = 0; i < out.len; i++) { + ASSERT_EQ(out.data[i], SharedSecret[i]); + } + HcfObjDestroy(keyAgreement); + HcfObjDestroy(eccSecp256k1KeyPair); + HcfFree(out.data); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest404, TestSize.Level0) +{ + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); + + HcfKeyPair *keyPair1 = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair1); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair1, nullptr); + + HcfKeyPair *keyPair2 = nullptr; + res = generator->generateKeyPair(generator, nullptr, &keyPair2); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyPair2, nullptr); + + HcfKeyAgreement *keyAgreement = nullptr; + res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(keyAgreement, nullptr); + + HcfBlob out1 = { .data = nullptr, .len = 0 }; + HcfBlob out2 = { .data = nullptr, .len = 0 }; + res = keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair2->pubKey, &out1); + ASSERT_EQ(res, HCF_SUCCESS); + res = keyAgreement->generateSecret(keyAgreement, keyPair2->priKey, keyPair1->pubKey, &out2); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_EQ(out1.len, out2.len); + for (int i = 0; i < out1.len; i++) { + ASSERT_EQ(out1.data[i], out2.data[i]); + } + HcfObjDestroy(keyAgreement); + HcfFree(out1.data); + HcfFree(out2.data); + HcfObjDestroy(keyPair1); + HcfObjDestroy(keyPair2); + HcfObjDestroy(generator); +} } diff --git a/test/unittest/src/ecc/crypto_ecc_verify_test.cpp b/test/unittest/src/ecc/crypto_ecc_verify_test.cpp index 2250e84..9cc3e8b 100644 --- a/test/unittest/src/ecc/crypto_ecc_verify_test.cpp +++ b/test/unittest/src/ecc/crypto_ecc_verify_test.cpp @@ -28,6 +28,29 @@ using namespace std; using namespace testing::ext; +static string eccSecp256k1PriKey = "-----BEGIN EC PRIVATE KEY-----\n" +"MHQCAQEEIIlLPqrfBGECZ65uHJTzZIjFipExXkecVOQnOggDaNXfoAcGBSuBBAAK\n" +"oUQDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1uCCTyoz/4RyMYC+xHS0klwV2\n" +"xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n" +"-----END EC PRIVATE KEY-----\n"; + +static string eccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n" +"MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1\n" +"uCCTyoz/4RyMYC+xHS0klwV2xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n" +"-----END PUBLIC KEY-----\n"; + +static uint8_t sig[] = {0x30, 0x44, 0x02, 0x20, 0x0F, 0xC8, 0xD8, 0x71, 0xE2, 0x61, 0x36, 0xA1, 0x07, 0x57, 0xDB, 0x00, + 0xE7, 0x89, 0x98, 0x95, 0xC7, 0xFF, 0x70, 0x71, 0xDD, 0x39, 0x82, 0x61, 0x0D, 0x71, 0xD3, 0x5E, + 0xB9, 0x36, 0x70, 0xDE, 0x02, 0x20, 0x54, 0xA9, 0x93, 0x6E, 0x14, 0xCC, 0x06, 0x4D, 0xD8, 0x42, + 0x51, 0x93, 0x47, 0x23, 0x9E, 0x6A, 0xA0, 0xD9, 0x8A, 0x4A, 0xA1, 0x74, 0x47, 0x83, 0xE3, 0xEF, + 0x07, 0x0B, 0x50, 0x9E, 0x43, 0x27}; + +static const char *g_message = "hello world"; +static HcfBlob input = { + .data = (uint8_t *)g_message, + .len = 11 +}; + namespace { class CryptoEccVerifyTest : public testing::Test { public: @@ -1894,4 +1917,88 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0) HcfObjDestroy(sign); HcfObjDestroy(verify); } + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) +{ + HcfKeyPair *eccSecp256k1KeyPair = nullptr; + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(), + eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(eccSecp256k1KeyPair, nullptr); + + HcfSign *sign = nullptr; + res = HcfSignCreate("ECC_Secp256k1|SHA256", &sign); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(sign, nullptr); + + res = sign->init(sign, nullptr, eccSecp256k1KeyPair->priKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = sign->update(sign, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + HcfBlob out = { .data = nullptr, .len = 0 }; + res = sign->sign(sign, nullptr, &out); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(out.data, nullptr); + ASSERT_NE(out.len, (const unsigned int)0); + + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_Secp256k1|SHA256", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, eccSecp256k1KeyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &g_mockInput); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, nullptr, &out); + ASSERT_EQ(flag, true); + + HcfFree(out.data); + HcfObjDestroy(sign); + HcfObjDestroy(verify); + HcfObjDestroy(eccSecp256k1KeyPair); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0) +{ + HcfKeyPair *eccSecp256k1KeyPair = nullptr; + HcfAsyKeyGenerator *generator = nullptr; + int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(generator, nullptr); + + res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(), + eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(eccSecp256k1KeyPair, nullptr); + + HcfBlob out = { .data = sig, .len = sizeof(sig) }; + HcfVerify *verify = nullptr; + res = HcfVerifyCreate("ECC_Secp256k1|SHA256", &verify); + ASSERT_EQ(res, HCF_SUCCESS); + ASSERT_NE(verify, nullptr); + + res = verify->init(verify, nullptr, eccSecp256k1KeyPair->pubKey); + ASSERT_EQ(res, HCF_SUCCESS); + + res = verify->update(verify, &input); + ASSERT_EQ(res, HCF_SUCCESS); + + bool flag = verify->verify(verify, nullptr, &out); + ASSERT_EQ(flag, true); + + HcfObjDestroy(verify); + HcfObjDestroy(eccSecp256k1KeyPair); + HcfObjDestroy(generator); +} } -- Gitee From 2ddd040550c92bc66feeaba4cb4cdf4da4a19100 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Sat, 2 Nov 2024 16:01:12 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E6=96=B0=E5=A2=9Ek1=E6=9B=B2=E7=BA=BF?= =?UTF-8?q?=E5=91=8A=E8=AD=A6=E6=B8=85=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 王静 --- .../src/ecc_asy_key_generator_openssl.c | 228 ++++++------------ .../ecc_common_param_spec_generator_openssl.c | 19 +- 2 files changed, 81 insertions(+), 166 deletions(-) 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 25bea46..1a46091 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 @@ -58,14 +58,10 @@ typedef struct { static HcfResult CheckEc224CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_ecc224CorrectBigP, NID_secp224r1_len, NULL); - bStd = OpensslBin2Bn(g_ecc224CorrectBigB, NID_secp224r1_len, NULL); - xStd = OpensslBin2Bn(g_ecc224CorrectBigGX, NID_secp224r1_len, NULL); - yStd = OpensslBin2Bn(g_ecc224CorrectBigGY, NID_secp224r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_ecc224CorrectBigP, NID_secp224r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_ecc224CorrectBigB, NID_secp224r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_ecc224CorrectBigGX, NID_secp224r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_ecc224CorrectBigGY, NID_secp224r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] EC 224 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -83,14 +79,10 @@ static HcfResult CheckEc224CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckEc256CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_ecc256CorrectBigP, NID_X9_62_prime256v1_len, NULL); - bStd = OpensslBin2Bn(g_ecc256CorrectBigB, NID_X9_62_prime256v1_len, NULL); - xStd = OpensslBin2Bn(g_ecc256CorrectBigGX, NID_X9_62_prime256v1_len, NULL); - yStd = OpensslBin2Bn(g_ecc256CorrectBigGY, NID_X9_62_prime256v1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_ecc256CorrectBigP, NID_X9_62_prime256v1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_ecc256CorrectBigB, NID_X9_62_prime256v1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_ecc256CorrectBigGX, NID_X9_62_prime256v1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_ecc256CorrectBigGY, NID_X9_62_prime256v1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] EC 256 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -108,14 +100,10 @@ static HcfResult CheckEc256CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckEc384CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_ecc384CorrectBigP, NID_secp384r1_len, NULL); - bStd = OpensslBin2Bn(g_ecc384CorrectBigB, NID_secp384r1_len, NULL); - xStd = OpensslBin2Bn(g_ecc384CorrectBigGX, NID_secp384r1_len, NULL); - yStd = OpensslBin2Bn(g_ecc384CorrectBigGY, NID_secp384r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_ecc384CorrectBigP, NID_secp384r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_ecc384CorrectBigB, NID_secp384r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_ecc384CorrectBigGX, NID_secp384r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_ecc384CorrectBigGY, NID_secp384r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] EC 384 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -133,14 +121,10 @@ static HcfResult CheckEc384CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckEc521CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_ecc521CorrectBigP, NID_secp521r1_len, NULL); - bStd = OpensslBin2Bn(g_ecc521CorrectBigB, NID_secp521r1_len, NULL); - xStd = OpensslBin2Bn(g_ecc521CorrectBigGX, NID_secp521r1_len, NULL); - yStd = OpensslBin2Bn(g_ecc521CorrectBigGY, NID_secp521r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_ecc521CorrectBigP, NID_secp521r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_ecc521CorrectBigB, NID_secp521r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_ecc521CorrectBigGX, NID_secp521r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_ecc521CorrectBigGY, NID_secp521r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] EC 521 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -158,14 +142,10 @@ static HcfResult CheckEc521CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP160r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp160r1CorrectBigP, NID_brainpoolP160r1_len, NULL); - bStd = OpensslBin2Bn(g_bp160r1CorrectBigB, NID_brainpoolP160r1_len, NULL); - xStd = OpensslBin2Bn(g_bp160r1CorrectBigGX, NID_brainpoolP160r1_len, NULL); - yStd = OpensslBin2Bn(g_bp160r1CorrectBigGY, NID_brainpoolP160r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp160r1CorrectBigP, NID_brainpoolP160r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp160r1CorrectBigB, NID_brainpoolP160r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp160r1CorrectBigGX, NID_brainpoolP160r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp160r1CorrectBigGY, NID_brainpoolP160r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 160r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -183,14 +163,10 @@ static HcfResult CheckBP160r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP160t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp160t1CorrectBigP, NID_brainpoolP160t1_len, NULL); - bStd = OpensslBin2Bn(g_bp160t1CorrectBigB, NID_brainpoolP160t1_len, NULL); - xStd = OpensslBin2Bn(g_bp160t1CorrectBigGX, NID_brainpoolP160t1_len, NULL); - yStd = OpensslBin2Bn(g_bp160t1CorrectBigGY, NID_brainpoolP160t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp160t1CorrectBigP, NID_brainpoolP160t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp160t1CorrectBigB, NID_brainpoolP160t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp160t1CorrectBigGX, NID_brainpoolP160t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp160t1CorrectBigGY, NID_brainpoolP160t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 160t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -208,14 +184,10 @@ static HcfResult CheckBP160t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP192r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp192r1CorrectBigP, NID_brainpoolP192r1_len, NULL); - bStd = OpensslBin2Bn(g_bp192r1CorrectBigB, NID_brainpoolP192r1_len, NULL); - xStd = OpensslBin2Bn(g_bp192r1CorrectBigGX, NID_brainpoolP192r1_len, NULL); - yStd = OpensslBin2Bn(g_bp192r1CorrectBigGY, NID_brainpoolP192r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp192r1CorrectBigP, NID_brainpoolP192r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp192r1CorrectBigB, NID_brainpoolP192r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp192r1CorrectBigGX, NID_brainpoolP192r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp192r1CorrectBigGY, NID_brainpoolP192r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 192r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -233,14 +205,10 @@ static HcfResult CheckBP192r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP192t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp192t1CorrectBigP, NID_brainpoolP192t1_len, NULL); - bStd = OpensslBin2Bn(g_bp192t1CorrectBigB, NID_brainpoolP192t1_len, NULL); - xStd = OpensslBin2Bn(g_bp192t1CorrectBigGX, NID_brainpoolP192t1_len, NULL); - yStd = OpensslBin2Bn(g_bp192t1CorrectBigGY, NID_brainpoolP192t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp192t1CorrectBigP, NID_brainpoolP192t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp192t1CorrectBigB, NID_brainpoolP192t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp192t1CorrectBigGX, NID_brainpoolP192t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp192t1CorrectBigGY, NID_brainpoolP192t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 192t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -258,14 +226,10 @@ static HcfResult CheckBP192t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP224r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp224r1CorrectBigP, NID_brainpoolP224r1_len, NULL); - bStd = OpensslBin2Bn(g_bp224r1CorrectBigB, NID_brainpoolP224r1_len, NULL); - xStd = OpensslBin2Bn(g_bp224r1CorrectBigGX, NID_brainpoolP224r1_len, NULL); - yStd = OpensslBin2Bn(g_bp224r1CorrectBigGY, NID_brainpoolP224r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp224r1CorrectBigP, NID_brainpoolP224r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp224r1CorrectBigB, NID_brainpoolP224r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp224r1CorrectBigGX, NID_brainpoolP224r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp224r1CorrectBigGY, NID_brainpoolP224r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 224r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -283,14 +247,10 @@ static HcfResult CheckBP224r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP224t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp224t1CorrectBigP, NID_brainpoolP224t1_len, NULL); - bStd = OpensslBin2Bn(g_bp224t1CorrectBigB, NID_brainpoolP224t1_len, NULL); - xStd = OpensslBin2Bn(g_bp224t1CorrectBigGX, NID_brainpoolP224t1_len, NULL); - yStd = OpensslBin2Bn(g_bp224t1CorrectBigGY, NID_brainpoolP224t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp224t1CorrectBigP, NID_brainpoolP224t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp224t1CorrectBigB, NID_brainpoolP224t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp224t1CorrectBigGX, NID_brainpoolP224t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp224t1CorrectBigGY, NID_brainpoolP224t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 224t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -308,14 +268,10 @@ static HcfResult CheckBP224t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP256r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp256r1CorrectBigP, NID_brainpoolP256r1_len, NULL); - bStd = OpensslBin2Bn(g_bp256r1CorrectBigB, NID_brainpoolP256r1_len, NULL); - xStd = OpensslBin2Bn(g_bp256r1CorrectBigGX, NID_brainpoolP256r1_len, NULL); - yStd = OpensslBin2Bn(g_bp256r1CorrectBigGY, NID_brainpoolP256r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp256r1CorrectBigP, NID_brainpoolP256r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp256r1CorrectBigB, NID_brainpoolP256r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp256r1CorrectBigGX, NID_brainpoolP256r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp256r1CorrectBigGY, NID_brainpoolP256r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 256r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -333,14 +289,10 @@ static HcfResult CheckBP256r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP256t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp256t1CorrectBigP, NID_brainpoolP256t1_len, NULL); - bStd = OpensslBin2Bn(g_bp256t1CorrectBigB, NID_brainpoolP256t1_len, NULL); - xStd = OpensslBin2Bn(g_bp256t1CorrectBigGX, NID_brainpoolP256t1_len, NULL); - yStd = OpensslBin2Bn(g_bp256t1CorrectBigGY, NID_brainpoolP256t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp256t1CorrectBigP, NID_brainpoolP256t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp256t1CorrectBigB, NID_brainpoolP256t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp256t1CorrectBigGX, NID_brainpoolP256t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp256t1CorrectBigGY, NID_brainpoolP256t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 256t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -357,14 +309,10 @@ static HcfResult CheckBP256t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckSecp256k1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_secp256k1CorrectBigP, NID_secp256k1_len, NULL); - bStd = OpensslBin2Bn(g_secp256k1CorrectBigB, NID_secp256k1_len, NULL); - xStd = OpensslBin2Bn(g_secp256k1CorrectBigGX, NID_secp256k1_len, NULL); - yStd = OpensslBin2Bn(g_secp256k1CorrectBigGY, NID_secp256k1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_secp256k1CorrectBigP, NID_secp256k1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_secp256k1CorrectBigB, NID_secp256k1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_secp256k1CorrectBigGX, NID_secp256k1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_secp256k1CorrectBigGY, NID_secp256k1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] Secp256k1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -381,14 +329,10 @@ static HcfResult CheckSecp256k1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM * static HcfResult CheckBP320r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp320r1CorrectBigP, NID_brainpoolP320r1_len, NULL); - bStd = OpensslBin2Bn(g_bp320r1CorrectBigB, NID_brainpoolP320r1_len, NULL); - xStd = OpensslBin2Bn(g_bp320r1CorrectBigGX, NID_brainpoolP320r1_len, NULL); - yStd = OpensslBin2Bn(g_bp320r1CorrectBigGY, NID_brainpoolP320r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp320r1CorrectBigP, NID_brainpoolP320r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp320r1CorrectBigB, NID_brainpoolP320r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp320r1CorrectBigGX, NID_brainpoolP320r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp320r1CorrectBigGY, NID_brainpoolP320r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 320r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -405,14 +349,10 @@ static HcfResult CheckBP320r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP320t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp320t1CorrectBigP, NID_brainpoolP320t1_len, NULL); - bStd = OpensslBin2Bn(g_bp320t1CorrectBigB, NID_brainpoolP320t1_len, NULL); - xStd = OpensslBin2Bn(g_bp320t1CorrectBigGX, NID_brainpoolP320t1_len, NULL); - yStd = OpensslBin2Bn(g_bp320t1CorrectBigGY, NID_brainpoolP320t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp320t1CorrectBigP, NID_brainpoolP320t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp320t1CorrectBigB, NID_brainpoolP320t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp320t1CorrectBigGX, NID_brainpoolP320t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp320t1CorrectBigGY, NID_brainpoolP320t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 320t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -429,14 +369,10 @@ static HcfResult CheckBP320t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP384r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp384r1CorrectBigP, NID_brainpoolP384r1_len, NULL); - bStd = OpensslBin2Bn(g_bp384r1CorrectBigB, NID_brainpoolP384r1_len, NULL); - xStd = OpensslBin2Bn(g_bp384r1CorrectBigGX, NID_brainpoolP384r1_len, NULL); - yStd = OpensslBin2Bn(g_bp384r1CorrectBigGY, NID_brainpoolP384r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp384r1CorrectBigP, NID_brainpoolP384r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp384r1CorrectBigB, NID_brainpoolP384r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp384r1CorrectBigGX, NID_brainpoolP384r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp384r1CorrectBigGY, NID_brainpoolP384r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 384r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -453,14 +389,10 @@ static HcfResult CheckBP384r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP384t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp384t1CorrectBigP, NID_brainpoolP384t1_len, NULL); - bStd = OpensslBin2Bn(g_bp384t1CorrectBigB, NID_brainpoolP384t1_len, NULL); - xStd = OpensslBin2Bn(g_bp384t1CorrectBigGX, NID_brainpoolP384t1_len, NULL); - yStd = OpensslBin2Bn(g_bp384t1CorrectBigGY, NID_brainpoolP384t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp384t1CorrectBigP, NID_brainpoolP384t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp384t1CorrectBigB, NID_brainpoolP384t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp384t1CorrectBigGX, NID_brainpoolP384t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp384t1CorrectBigGY, NID_brainpoolP384t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 384t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -477,14 +409,10 @@ static HcfResult CheckBP384t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP512r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp512r1CorrectBigP, NID_brainpoolP512r1_len, NULL); - bStd = OpensslBin2Bn(g_bp512r1CorrectBigB, NID_brainpoolP512r1_len, NULL); - xStd = OpensslBin2Bn(g_bp512r1CorrectBigGX, NID_brainpoolP512r1_len, NULL); - yStd = OpensslBin2Bn(g_bp512r1CorrectBigGY, NID_brainpoolP512r1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp512r1CorrectBigP, NID_brainpoolP512r1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp512r1CorrectBigB, NID_brainpoolP512r1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp512r1CorrectBigGX, NID_brainpoolP512r1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp512r1CorrectBigGY, NID_brainpoolP512r1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 512r1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); @@ -501,14 +429,10 @@ static HcfResult CheckBP512r1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) static HcfResult CheckBP512t1CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y) { - BIGNUM *pStd = NULL; - BIGNUM *bStd = NULL; - BIGNUM *xStd = NULL; - BIGNUM *yStd = NULL; - pStd = OpensslBin2Bn(g_bp512t1CorrectBigP, NID_brainpoolP512t1_len, NULL); - bStd = OpensslBin2Bn(g_bp512t1CorrectBigB, NID_brainpoolP512t1_len, NULL); - xStd = OpensslBin2Bn(g_bp512t1CorrectBigGX, NID_brainpoolP512t1_len, NULL); - yStd = OpensslBin2Bn(g_bp512t1CorrectBigGY, NID_brainpoolP512t1_len, NULL); + BIGNUM *pStd = OpensslBin2Bn(g_bp512t1CorrectBigP, NID_brainpoolP512t1_len, NULL); + BIGNUM *bStd = OpensslBin2Bn(g_bp512t1CorrectBigB, NID_brainpoolP512t1_len, NULL); + BIGNUM *xStd = OpensslBin2Bn(g_bp512t1CorrectBigGX, NID_brainpoolP512t1_len, NULL); + BIGNUM *yStd = OpensslBin2Bn(g_bp512t1CorrectBigGY, NID_brainpoolP512t1_len, NULL); if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) { LOGD("[error] BP 512t1 Curve convert to BN fail"); FreeCurveBigNum(pStd, bStd, xStd, yStd); diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c index e7c6e35..59d64f1 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c @@ -95,22 +95,14 @@ static HcfResult BuildCommonParamPart(const EC_GROUP *ecGroup, HcfEccCommParamsS static HcfResult BuildCommonParamGFp(const EC_GROUP *ecGroup, HcfEccCommParamsSpecSpi *returnCommonParamSpec) { BIGNUM *p = OpensslBnNew(); - if (p == NULL) { - LOGE("New p failed."); - return HCF_ERR_MALLOC; - } BIGNUM *a = OpensslBnNew(); - if (a == NULL) { - LOGE("New a failed."); - OpensslBnFree(p); - return HCF_ERR_MALLOC; - } BIGNUM *b = OpensslBnNew(); - if (b == NULL) { - LOGE("New b failed."); + if (p == NULL || a == NULL || b == NULL) { + LOGD("[error] new BN failed."); OpensslBnFree(p); OpensslBnFree(a); - return HCF_ERR_MALLOC; + OpensslBnFree(b); + return HCF_ERR_CRYPTO_OPERATION; } if (!OpensslEcGroupGetCurveGfp(ecGroup, p, a, b, NULL)) { LOGE("EC_GROUP_get_curve_GFp failed."); @@ -120,9 +112,8 @@ static HcfResult BuildCommonParamGFp(const EC_GROUP *ecGroup, HcfEccCommParamsSp return HCF_ERR_CRYPTO_OPERATION; } HcfResult ret = HCF_SUCCESS; - int curveId = OpensslEcGroupGetCurveName(ecGroup); do { - if (curveId == NID_secp256k1) { + if (OpensslEcGroupGetCurveName(ecGroup) == NID_secp256k1) { if (BigNumToBigIntegerSecp256k1(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { LOGE("Build Secp256k1CommonParamSpec a failed."); ret = HCF_ERR_CRYPTO_OPERATION; -- Gitee From 262e38564b6ade95a65af3f3e47070d8e07c6803 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Tue, 26 Nov 2024 17:49:22 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E5=91=8A=E8=AD=A6=E6=B8=85=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 王静 --- .../ecc_common_param_spec_generator_openssl.c | 2 +- .../src/crypto_ecc_key_agreement_test.cpp | 47 --------------- .../src/ecc/crypto_ecc_verify_test.cpp | 59 +------------------ 3 files changed, 2 insertions(+), 106 deletions(-) diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c index 59d64f1..8021e76 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/ecc_common_param_spec_generator_openssl.c @@ -120,7 +120,7 @@ static HcfResult BuildCommonParamGFp(const EC_GROUP *ecGroup, HcfEccCommParamsSp break; } } else { - if (BigNumToBigInteger(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { + if (BigNumToBigInteger(a, &(returnCommonParamSpec->paramsSpec.a)) != HCF_SUCCESS) { LOGE("Build commonParamSpec a failed."); ret = HCF_ERR_CRYPTO_OPERATION; break; diff --git a/test/unittest/src/crypto_ecc_key_agreement_test.cpp b/test/unittest/src/crypto_ecc_key_agreement_test.cpp index 51df04d..62264ed 100644 --- a/test/unittest/src/crypto_ecc_key_agreement_test.cpp +++ b/test/unittest/src/crypto_ecc_key_agreement_test.cpp @@ -28,22 +28,6 @@ using namespace std; using namespace testing::ext; -static string g_testEccSecp256k1PriKey = "-----BEGIN PRIVATE KEY-----\n" -"MIGEAgEAMBAGByqGSM49AgEGBSuBBAAKBG0wawIBAQQgHCRzy0IcEx6CeA6ogNNK\n" -"SOfuTlHy4fE/LNxkANUS4k+hRANCAASDBmwKklX4OcbZSJJX9mxm1Wr7TPTLpbyp\n" -"xKcKRm0XKNxVlrZU8WQCl66GtX2DDyX+0+XiC3hbaRWcYtg7P6WO\n" -"-----END PRIVATE KEY-----\n"; - -static string g_testEccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n" -"MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEBUKCHJHsvlcod0MCVlFHylzW241nveMm\n" -"RAFhryNgX6rVqooGReVUm+WiF7Uz0ZsIjdHKd9HHe+2BOWfnuWyR1A==\n" -"-----END PUBLIC KEY-----\n"; - -static uint8_t SharedSecret[] = {0xaf, 0x43, 0xb5, 0x27, 0x90, 0x08, 0x2f, 0xd8, - 0x7a, 0xfb, 0x1d, 0x14, 0xb8, 0x83, 0xc1, 0x2d, - 0x12, 0xbb, 0x9e, 0x55, 0x40, 0x80, 0xd1, 0xf8, - 0xe5, 0x27, 0x92, 0x06, 0x76, 0xe3, 0x1f, 0x3e}; - namespace { class CryptoEccKeyAgreementTest : public testing::Test { public: @@ -746,37 +730,6 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccCommonTest01, TestSize.Level0) EXPECT_EQ(ret, HCF_INVALID_PARAMS); } -HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest403, TestSize.Level0) -{ - HcfKeyAgreement *keyAgreement = nullptr; - int32_t res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement); - - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(keyAgreement, nullptr); - HcfBlob out = { .data = nullptr, .len = 0 }; - HcfKeyPair *eccSecp256k1KeyPair = nullptr; - HcfAsyKeyGenerator *generator = nullptr; - res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(generator, nullptr); - - res = generator->convertPemKey(generator, nullptr, g_testEccSecp256k1PubKey.c_str(), - g_testEccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(eccSecp256k1KeyPair, nullptr); - - res = keyAgreement->generateSecret(keyAgreement, eccSecp256k1KeyPair->priKey, eccSecp256k1KeyPair->pubKey, &out); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_EQ(out.len, sizeof(SharedSecret)); - for (int i = 0; i < out.len; i++) { - ASSERT_EQ(out.data[i], SharedSecret[i]); - } - HcfObjDestroy(keyAgreement); - HcfObjDestroy(eccSecp256k1KeyPair); - HcfFree(out.data); - HcfObjDestroy(generator); -} - HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest404, TestSize.Level0) { HcfAsyKeyGenerator *generator = nullptr; diff --git a/test/unittest/src/ecc/crypto_ecc_verify_test.cpp b/test/unittest/src/ecc/crypto_ecc_verify_test.cpp index 9cc3e8b..c90afc6 100644 --- a/test/unittest/src/ecc/crypto_ecc_verify_test.cpp +++ b/test/unittest/src/ecc/crypto_ecc_verify_test.cpp @@ -28,29 +28,6 @@ using namespace std; using namespace testing::ext; -static string eccSecp256k1PriKey = "-----BEGIN EC PRIVATE KEY-----\n" -"MHQCAQEEIIlLPqrfBGECZ65uHJTzZIjFipExXkecVOQnOggDaNXfoAcGBSuBBAAK\n" -"oUQDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1uCCTyoz/4RyMYC+xHS0klwV2\n" -"xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n" -"-----END EC PRIVATE KEY-----\n"; - -static string eccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n" -"MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1\n" -"uCCTyoz/4RyMYC+xHS0klwV2xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n" -"-----END PUBLIC KEY-----\n"; - -static uint8_t sig[] = {0x30, 0x44, 0x02, 0x20, 0x0F, 0xC8, 0xD8, 0x71, 0xE2, 0x61, 0x36, 0xA1, 0x07, 0x57, 0xDB, 0x00, - 0xE7, 0x89, 0x98, 0x95, 0xC7, 0xFF, 0x70, 0x71, 0xDD, 0x39, 0x82, 0x61, 0x0D, 0x71, 0xD3, 0x5E, - 0xB9, 0x36, 0x70, 0xDE, 0x02, 0x20, 0x54, 0xA9, 0x93, 0x6E, 0x14, 0xCC, 0x06, 0x4D, 0xD8, 0x42, - 0x51, 0x93, 0x47, 0x23, 0x9E, 0x6A, 0xA0, 0xD9, 0x8A, 0x4A, 0xA1, 0x74, 0x47, 0x83, 0xE3, 0xEF, - 0x07, 0x0B, 0x50, 0x9E, 0x43, 0x27}; - -static const char *g_message = "hello world"; -static HcfBlob input = { - .data = (uint8_t *)g_message, - .len = 11 -}; - namespace { class CryptoEccVerifyTest : public testing::Test { public: @@ -1926,8 +1903,7 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(generator, nullptr); - res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(), - eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); + res = generator->generateKeyPair(generator, nullptr, &eccSecp256k1KeyPair); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(eccSecp256k1KeyPair, nullptr); @@ -1968,37 +1944,4 @@ HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0) HcfObjDestroy(eccSecp256k1KeyPair); HcfObjDestroy(generator); } - -HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0) -{ - HcfKeyPair *eccSecp256k1KeyPair = nullptr; - HcfAsyKeyGenerator *generator = nullptr; - int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(generator, nullptr); - - res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(), - eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(eccSecp256k1KeyPair, nullptr); - - HcfBlob out = { .data = sig, .len = sizeof(sig) }; - HcfVerify *verify = nullptr; - res = HcfVerifyCreate("ECC_Secp256k1|SHA256", &verify); - ASSERT_EQ(res, HCF_SUCCESS); - ASSERT_NE(verify, nullptr); - - res = verify->init(verify, nullptr, eccSecp256k1KeyPair->pubKey); - ASSERT_EQ(res, HCF_SUCCESS); - - res = verify->update(verify, &input); - ASSERT_EQ(res, HCF_SUCCESS); - - bool flag = verify->verify(verify, nullptr, &out); - ASSERT_EQ(flag, true); - - HcfObjDestroy(verify); - HcfObjDestroy(eccSecp256k1KeyPair); - HcfObjDestroy(generator); -} } -- Gitee