From c137aee7f248861fba5e955850171d85cea86f1a 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] =?UTF-8?q?EC=E5=AF=86=E9=92=A5=E8=A7=84=E6=A0=BC=E6=96=B0?= =?UTF-8?q?=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 a136084..d96d65f 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 3669142..668741a 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 3289032..6dd7663 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 336c18d..e41558d 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: @@ -731,4 +747,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