From a9ab282fcb868101b13580c72a925cfe61ba49ac Mon Sep 17 00:00:00 2001 From: zzh593245631 Date: Wed, 21 May 2025 17:36:53 +0800 Subject: [PATCH 1/2] =?UTF-8?q?CAPI=E9=97=AE=E9=A2=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zzh Change-Id: I83df5ecc2b1bd9b0cb4d3bc21ac09e4c47f71c1b --- frameworks/native/src/asym_key.c | 37 ++++++++++++++----- frameworks/native/src/native_common.c | 4 +- .../src/rsa_asy_key_generator_openssl.c | 2 +- .../src/native/native_asym_key_test.cpp | 2 + 4 files changed, 33 insertions(+), 12 deletions(-) diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c index 43b7d5d..60b9724 100644 --- a/frameworks/native/src/asym_key.c +++ b/frameworks/native/src/asym_key.c @@ -159,8 +159,23 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c return CRYPTO_INVALID_PARAMS; } HcfResult ret = HCF_SUCCESS; - const char *priKeyStr = (priKeyData == NULL)? NULL : (const char *)priKeyData->data; - const char *pubKeyStr = (pubKeyData == NULL)? NULL : (const char *)pubKeyData->data; + char *priKeyStr = NULL; + if (priKeyData != NULL) { + priKeyStr = (char *)HcfMalloc(priKeyData->len + 1, 0); + if (priKeyStr == NULL) { + return CRYPTO_MEMORY_ERROR; + } + (void)memcpy_s(priKeyStr, priKeyData->len, priKeyData->data, priKeyData->len); + } + char *pubKeyStr = NULL; + if (pubKeyData != NULL) { + pubKeyStr = (char *)HcfMalloc(pubKeyData->len + 1, 0); + if (pubKeyStr == NULL) { + HcfFree(priKeyStr); + return CRYPTO_MEMORY_ERROR; + } + (void)memcpy_s(pubKeyStr, pubKeyData->len, pubKeyData->data, pubKeyData->len); + } switch (type) { case CRYPTO_PEM: ret = ctx->base->convertPemKey == NULL ? HCF_INVALID_PARAMS : @@ -173,8 +188,12 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); break; default: + HcfFree(priKeyStr); + HcfFree(pubKeyStr); return CRYPTO_INVALID_PARAMS; } + HcfFree(priKeyStr); + HcfFree(pubKeyStr); return GetOhCryptoErrCode(ret); } @@ -310,6 +329,7 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P } value->data = (uint8_t *)returnInt; value->len = sizeof(int32_t); + ReverseUint8Arr(value->data, value->len); break; case CRYPTO_ECC_FIELD_TYPE_STR: case CRYPTO_ECC_CURVE_NAME_STR: @@ -329,6 +349,7 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P } value->data = (uint8_t *)bigIntValue.data; value->len = (size_t)bigIntValue.len; + ReverseUint8Arr(value->data, value->len); break; } return GetOhCryptoErrCode(ret); @@ -398,12 +419,6 @@ OH_Crypto_ErrCode OH_CryptoPrivKey_Encode(OH_CryptoPrivKey *key, Crypto_Encoding if (key->getEncodedPem == NULL) { return CRYPTO_PARAMETER_CHECK_FAILED; } - if (params == NULL) { - ret = key->getEncodedPem((HcfPriKey *)key, NULL, encodingStandard, &pemStr); - } else { - ret = key->getEncodedPem((HcfPriKey *)key, (HcfParamsSpec *)params, encodingStandard, &pemStr); - } - ret = key->getEncodedPem((HcfPriKey *)key, (HcfParamsSpec *)params, encodingStandard, &pemStr); if (ret != HCF_SUCCESS) { break; @@ -1581,7 +1596,7 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_Create(const char *curveName, Crypto_DataBlob } HcfResult ret = HcfConvertPoint(curveName, (HcfBlob *)ecKeyData, &((*point)->pointBase)); if (ret != HCF_SUCCESS) { - HcfFree(*point); + OH_CryptoEcPoint_Destroy(*point); *point = NULL; } return GetOhCryptoErrCodeNew(ret); @@ -1601,6 +1616,8 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_GetCoordinate(OH_CryptoEcPoint *point, Crypto y->data = dPoint.y.data; x->len = dPoint.x.len; y->len = dPoint.y.len; + ReverseUint8Arr(x->data, x->len); + ReverseUint8Arr(y->data, y->len); return CRYPTO_SUCCESS; } @@ -1625,6 +1642,8 @@ OH_Crypto_ErrCode OH_CryptoEcPoint_SetCoordinate(OH_CryptoEcPoint *point, Crypto point->pointBase.x.len = dPoint.x.len; point->pointBase.y.data = dPoint.y.data; point->pointBase.y.len = dPoint.y.len; + ReverseUint8Arr(point->pointBase.x.data, point->pointBase.x.len); + ReverseUint8Arr(point->pointBase.y.data, point->pointBase.y.len); return CRYPTO_SUCCESS; } diff --git a/frameworks/native/src/native_common.c b/frameworks/native/src/native_common.c index a9579a0..62b7fd3 100644 --- a/frameworks/native/src/native_common.c +++ b/frameworks/native/src/native_common.c @@ -49,11 +49,11 @@ OH_Crypto_ErrCode GetOhCryptoErrCodeNew(HcfResult errCode) void ReverseUint8Arr(uint8_t *data, size_t len) { - for (size_t i = 0; i < len / 2; ++i) { + for (size_t i = 0; i < (len >> 1); ++i) { uint8_t temp = data[i]; data[i] = data[len - 1 - i]; data[len - 1 - i] = temp; - } + } } #define NATIVE_BITS_SIZE 8 diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c index a374d68..08d887e 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/rsa_asy_key_generator_openssl.c @@ -724,13 +724,13 @@ static HcfResult GetPriKeyEncodedPem(const HcfPriKey *self, HcfParamsSpec *param OpensslEvpPkeyFree(pkey); return HCF_NOT_SUPPORT; } - cipher = EVP_CIPHER_fetch(NULL, cipherStr, NULL); passWord = (const char *)spec->password; if (passWord == NULL) { LOGE("passWord is NULL."); OpensslEvpPkeyFree(pkey); return HCF_ERR_PARAMETER_CHECK_FAILED; } + cipher = EVP_CIPHER_fetch(NULL, cipherStr, NULL); result = GetPriKeyPem(format, pkey, cipher, passWord, returnString); EVP_CIPHER_free((EVP_CIPHER *)cipher); } else { diff --git a/test/unittest/src/native/native_asym_key_test.cpp b/test/unittest/src/native/native_asym_key_test.cpp index 9017fae..584e8e6 100644 --- a/test/unittest/src/native/native_asym_key_test.cpp +++ b/test/unittest/src/native/native_asym_key_test.cpp @@ -1063,6 +1063,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest022, TestSize.Level0) OH_CryptoKeyPair *keyPair = nullptr; ret = GenerateKeyPairWithSpec(keySpec, &keyPair); + // 输入使用大端时会校验成功 EXPECT_EQ(ret, CRYPTO_SUCCESS); ASSERT_NE(keyPair, nullptr); ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr); @@ -1109,6 +1110,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest023, TestSize.Level0) OH_CryptoKeyPair *keyPair = nullptr; ret = GenerateKeyPairWithSpec(keySpec, &keyPair); + // 输入使用大端时会校验成功 EXPECT_EQ(ret, CRYPTO_SUCCESS); ASSERT_NE(keyPair, nullptr); ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr); -- Gitee From ce67553c2d74208892eff553d277539ae9c43039 Mon Sep 17 00:00:00 2001 From: zzh593245631 Date: Fri, 23 May 2025 18:31:17 +0800 Subject: [PATCH 2/2] =?UTF-8?q?issue=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zzh Change-Id: I143870b1658e076f247d649186205c9cdb6cb0b6 --- frameworks/native/src/asym_key.c | 103 ++++++++++++++++++++++--------- 1 file changed, 73 insertions(+), 30 deletions(-) diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c index 60b9724..5f85270 100644 --- a/frameworks/native/src/asym_key.c +++ b/frameworks/native/src/asym_key.c @@ -152,49 +152,92 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_SetPassword(OH_CryptoAsymKeyGenerato return CRYPTO_SUCCESS; } +static OH_Crypto_ErrCode ProcessPriKeyData(Crypto_DataBlob *priKeyData, char **priKeyStr) +{ + if (priKeyData == NULL) { + return CRYPTO_SUCCESS; + } + + *priKeyStr = (char *)HcfMalloc(priKeyData->len + 1, 0); + if (*priKeyStr == NULL) { + return CRYPTO_MEMORY_ERROR; + } + (void)memcpy_s(*priKeyStr, priKeyData->len, priKeyData->data, priKeyData->len); + return CRYPTO_SUCCESS; +} + +static OH_Crypto_ErrCode ProcessPubKeyData(Crypto_DataBlob *pubKeyData, char **pubKeyStr) +{ + if (pubKeyData == NULL) { + return CRYPTO_SUCCESS; + } + + *pubKeyStr = (char *)HcfMalloc(pubKeyData->len + 1, 0); + if (*pubKeyStr == NULL) { + return CRYPTO_MEMORY_ERROR; + } + (void)memcpy_s(*pubKeyStr, pubKeyData->len, pubKeyData->data, pubKeyData->len); + return CRYPTO_SUCCESS; +} + +static HcfResult ExecutePemConversion(OH_CryptoAsymKeyGenerator *ctx, char *pubKeyStr, + char *priKeyStr, OH_CryptoKeyPair **keyCtx) +{ + return ctx->base->convertPemKey == NULL ? HCF_INVALID_PARAMS : + ctx->base->convertPemKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec), + pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx); +} + +static void CleanupPemMemory(char *priKeyStr, char *pubKeyStr) +{ + if (priKeyStr != NULL) { + (void)memset_s(priKeyStr, strlen(priKeyStr), 0, strlen(priKeyStr)); + HcfFree(priKeyStr); + } + if (pubKeyStr != NULL) { + (void)memset_s(pubKeyStr, strlen(pubKeyStr), 0, strlen(pubKeyStr)); + HcfFree(pubKeyStr); + } +} + +static OH_Crypto_ErrCode HandlePemConversion(OH_CryptoAsymKeyGenerator *ctx, Crypto_DataBlob *pubKeyData, + Crypto_DataBlob *priKeyData, OH_CryptoKeyPair **keyCtx) +{ + char *priKeyStr = NULL; + char *pubKeyStr = NULL; + OH_Crypto_ErrCode ret = ProcessPriKeyData(priKeyData, &priKeyStr); + if (ret != CRYPTO_SUCCESS) { + return ret; + } + + ret = ProcessPubKeyData(pubKeyData, &pubKeyStr); + if (ret != CRYPTO_SUCCESS) { + CleanupPemMemory(priKeyStr, pubKeyStr); + return ret; + } + + HcfResult hcfRet = ExecutePemConversion(ctx, pubKeyStr, priKeyStr, keyCtx); + CleanupPemMemory(priKeyStr, pubKeyStr); + return GetOhCryptoErrCode(hcfRet); +} + OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *ctx, Crypto_EncodingType type, Crypto_DataBlob *pubKeyData, Crypto_DataBlob *priKeyData, OH_CryptoKeyPair **keyCtx) { if ((ctx == NULL) || (ctx->base == NULL) || (pubKeyData == NULL && priKeyData == NULL) || (keyCtx == NULL)) { return CRYPTO_INVALID_PARAMS; } - HcfResult ret = HCF_SUCCESS; - char *priKeyStr = NULL; - if (priKeyData != NULL) { - priKeyStr = (char *)HcfMalloc(priKeyData->len + 1, 0); - if (priKeyStr == NULL) { - return CRYPTO_MEMORY_ERROR; - } - (void)memcpy_s(priKeyStr, priKeyData->len, priKeyData->data, priKeyData->len); - } - char *pubKeyStr = NULL; - if (pubKeyData != NULL) { - pubKeyStr = (char *)HcfMalloc(pubKeyData->len + 1, 0); - if (pubKeyStr == NULL) { - HcfFree(priKeyStr); - return CRYPTO_MEMORY_ERROR; - } - (void)memcpy_s(pubKeyStr, pubKeyData->len, pubKeyData->data, pubKeyData->len); - } + switch (type) { case CRYPTO_PEM: - ret = ctx->base->convertPemKey == NULL ? HCF_INVALID_PARAMS : - ctx->base->convertPemKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec), pubKeyStr, - priKeyStr, (HcfKeyPair **)keyCtx); - break; + return HandlePemConversion(ctx, pubKeyData, priKeyData, keyCtx); case CRYPTO_DER: - ret = ctx->base->convertKey == NULL ? HCF_INVALID_PARAMS : + return GetOhCryptoErrCode(ctx->base->convertKey == NULL ? HCF_INVALID_PARAMS : ctx->base->convertKey((HcfAsyKeyGenerator *)(ctx->base), (HcfParamsSpec *)(ctx->decSpec), - (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); - break; + (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx)); default: - HcfFree(priKeyStr); - HcfFree(pubKeyStr); return CRYPTO_INVALID_PARAMS; } - HcfFree(priKeyStr); - HcfFree(pubKeyStr); - return GetOhCryptoErrCode(ret); } const char *OH_CryptoAsymKeyGenerator_GetAlgoName(OH_CryptoAsymKeyGenerator *ctx) -- Gitee