From 733eedf336276db0ad65a0d3317a70372e0b24f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Fri, 5 Jul 2024 17:58:59 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A4=96=E9=83=A8PEM=E5=BD=A2=E5=BC=8F?= =?UTF-8?q?=E5=AF=86=E9=92=A5=E6=95=B0=E6=8D=AE=E8=BD=AC=E6=8D=A2=E6=88=90?= =?UTF-8?q?=E7=AE=97=E6=B3=95=E5=BA=93=E5=AF=86=E9=92=A5=E5=AF=B9=E8=B1=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 王静 --- .../crypto/src/napi_asy_key_generator.cpp | 4 + frameworks/key/asy_key_generator.c | 5 + .../common/inc/openssl_adapter.h | 10 + .../common/inc/openssl_common.h | 1 + .../common/src/openssl_adapter.c | 30 ++- .../common/src/openssl_common.c | 29 +++ .../inc/ecc_asy_key_generator_openssl.h | 1 - .../inc/sm2_asy_key_generator_openssl.h | 1 + .../src/alg_25519_asy_key_generator_openssl.c | 163 +++++++++++++++ .../src/dh_asy_key_generator_openssl.c | 169 +++++++++++++++ .../src/dsa_asy_key_generator_openssl.c | 135 ++++++++++++ .../src/ecc_asy_key_generator_openssl.c | 135 ++++++++++++ .../src/sm2_asy_key_generator_openssl.c | 197 ++++++++++++++++++ 13 files changed, 878 insertions(+), 2 deletions(-) diff --git a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp index b301fde..a81cb7d 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -482,9 +482,11 @@ static void ConvertKeyAsyncWorkProcess(napi_env env, void *data) static void ConvertPemKeyAsyncWorkProcess(napi_env env, void *data) { + LOGE("[wjtest]ConvertPemKeyAsyncWorkProcess enter."); ConvertPemKeyCtx *ctx = static_cast(data); ctx->errCode = ctx->generator->convertPemKey(ctx->generator, ctx->params, ctx->pubKey.c_str(), ctx->priKey.c_str(), &(ctx->returnKeyPair)); + LOGE("[wjtest]ConvertPemKeyAsyncWorkProcess ctx->errCode = %d.", ctx->errCode); if (ctx->errCode != HCF_SUCCESS) { LOGE("ConvertPemKey fail."); ctx->errMsg = "ConvertPemKey fail."; @@ -620,6 +622,7 @@ static napi_value NewConvertKeyAsyncWork(napi_env env, ConvertKeyCtx *ctx) static napi_value NewConvertPemKeyAsyncWork(napi_env env, ConvertPemKeyCtx *ctx) { + LOGE("[wjtest]NewConvertPemKeyAsyncWork enter."); napi_value resourceName = nullptr; napi_create_string_utf8(env, "convertPemKey", NAPI_AUTO_LENGTH, &resourceName); napi_create_async_work( @@ -823,6 +826,7 @@ napi_value NapiAsyKeyGenerator::JsConvertKeySync(napi_env env, napi_callback_inf napi_value NapiAsyKeyGenerator::JsConvertPemKey(napi_env env, napi_callback_info info) { + LOGE("[wjtest]JsConvertPemKey enter."); ConvertPemKeyCtx *ctx = static_cast(HcfMalloc(sizeof(ConvertPemKeyCtx), 0)); if (ctx == nullptr) { LOGE("create context fail."); diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index c3ff4bf..75c44de 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -1240,14 +1240,19 @@ static HcfResult ConvertKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, Hcf static HcfResult ConvertPemKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, const char *pubKeyStr, const char *priKeyStr, HcfKeyPair **returnKeyPair) { + LOGE("[wjtest]ConvertPemKey enter."); if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } + LOGE("[wjtest]ConvertPemKey ---1."); if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { + LOGE("[wjtest]ConvertPemKey ---2."); return HCF_INVALID_PARAMS; } + LOGE("[wjtest]ConvertPemKey ---3."); HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + LOGE("[wjtest]ConvertPemKey ---4."); return impl->spiObj->engineConvertPemKey(impl->spiObj, params, pubKeyStr, priKeyStr, returnKeyPair); } diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h index edfc145..483144f 100644 --- a/plugin/openssl_plugin/common/inc/openssl_adapter.h +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -36,6 +36,8 @@ #include #include +#include +#include #ifdef __cplusplus extern "C" { @@ -391,6 +393,14 @@ OSSL_DECODER_CTX *OpensslOsslDecoderCtxNewForPkey(EVP_PKEY **pkey, const char *i int OpensslOsslDecoderFromData(OSSL_DECODER_CTX *ctx, const unsigned char **pdata, size_t *len); void OpensslOsslDecoderCtxFree(OSSL_DECODER_CTX *ctx); +int OpensslEvpPkeyIsA(const EVP_PKEY *pkey, const char *name); +EC_KEY *OpensslEcKeyNewbyCurveNameEX(OSSL_LIB_CTX *ctx, const char *propq, int nid); +int OpensslEvpPkeyGetOctetStringParam(const EVP_PKEY *pkey, const char *keyName, + unsigned char *buf, size_t maxBufSz, + size_t *outLen); +void OpensslEcKeySetFlags(EC_KEY *key, int flags); +int OpensslEvpPkeyGetBnParam(const EVP_PKEY *pkey, const char *keyName, + BIGNUM **bn); #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index b1f3ab3..0854774 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -70,6 +70,7 @@ HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret); HcfResult GetKeyEncodedPem(EVP_PKEY *pkey, const char *outPutStruct, int selection, char **returnString); +HcfResult ConvertPemStrToKey(const char *keyStr, int selection, const char *keyType, EVP_PKEY **pkey); #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c index ece03d1..d040632 100644 --- a/plugin/openssl_plugin/common/src/openssl_adapter.c +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -1502,4 +1502,32 @@ int OpensslOsslDecoderFromData(OSSL_DECODER_CTX *ctx, const unsigned char **pdat void OpensslOsslDecoderCtxFree(OSSL_DECODER_CTX *ctx) { OSSL_DECODER_CTX_free(ctx); -} \ No newline at end of file +} + +int OpensslEvpPkeyIsA(const EVP_PKEY *pkey, const char *name) +{ + return EVP_PKEY_is_a(pkey, name); +} + +EC_KEY *OpensslEcKeyNewbyCurveNameEX(OSSL_LIB_CTX *ctx, const char *propq, int nid) +{ + return EC_KEY_new_by_curve_name_ex(ctx, propq, nid); +} + +int OpensslEvpPkeyGetOctetStringParam(const EVP_PKEY *pkey, const char *keyName, + unsigned char *buf, size_t maxBufSz, + size_t *outLen) +{ + return EVP_PKEY_get_octet_string_param(pkey, keyName, buf, maxBufSz, outLen); +} + +void OpensslEcKeySetFlags(EC_KEY *key, int flags) +{ + EC_KEY_set_flags(key, flags); +} + +int OpensslEvpPkeyGetBnParam(const EVP_PKEY *pkey, const char *keyName, + BIGNUM **bn) +{ + return EVP_PKEY_get_bn_param(pkey, keyName, bn); +} diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 6924f34..694c075 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -577,3 +577,32 @@ HcfResult GetKeyEncodedPem(EVP_PKEY *pkey, const char *outPutStruct, int selecti OpensslOsslEncoderCtxFree(ctx); return HCF_SUCCESS; } + +HcfResult ConvertPemStrToKey(const char *keyStr, int selection, const char *keyType, EVP_PKEY **pkey) +{ + LOGE("[wjtest]ConvertPemKeyToKey enter."); + const char *inputType = "PEM"; + OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(pkey, inputType, + NULL, keyType, selection, NULL, NULL); + if (ctx == NULL) { + LOGE("OpensslOsslDecoderCtxNewForPkey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + size_t pdataLen = strlen(keyStr); + const unsigned char *pdata = (const unsigned char *)keyStr; + int ret = OpensslOsslDecoderFromData(ctx, &pdata, &pdataLen); + OpensslOsslDecoderCtxFree(ctx); + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("OpensslOsslDecoderFromData failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + if (*pkey == NULL) { + LOGE("[wjtest]ConvertPemKeyToKey *pkey is null."); + } else { + LOGE("[wjtest]ConvertPemKeyToKey *pkey is not null."); + } + LOGE("[wjtest]ConvertPemKeyToKey exit."); + return HCF_SUCCESS; +} diff --git a/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_asy_key_generator_openssl.h b/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_asy_key_generator_openssl.h index 4f757bd..a076c13 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_asy_key_generator_openssl.h +++ b/plugin/openssl_plugin/key/asy_key_generator/inc/ecc_asy_key_generator_openssl.h @@ -19,7 +19,6 @@ #include "asy_key_generator_spi.h" #include "params_parser.h" #include "result.h" - #ifdef __cplusplus extern "C" { #endif diff --git a/plugin/openssl_plugin/key/asy_key_generator/inc/sm2_asy_key_generator_openssl.h b/plugin/openssl_plugin/key/asy_key_generator/inc/sm2_asy_key_generator_openssl.h index 9c0840d..ec17572 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/inc/sm2_asy_key_generator_openssl.h +++ b/plugin/openssl_plugin/key/asy_key_generator/inc/sm2_asy_key_generator_openssl.h @@ -17,6 +17,7 @@ #define HCF_SM2_ASY_KEY_GENERATOR_OPENSSL_H #include "asy_key_generator_spi.h" +#include "ecc_asy_key_generator_openssl.h" #include "params_parser.h" #include "result.h" diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/alg_25519_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/alg_25519_asy_key_generator_openssl.c index 29d1236..c7071c8 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/alg_25519_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/alg_25519_asy_key_generator_openssl.c @@ -638,6 +638,75 @@ static HcfResult ConvertAlg25519PubKey(const HcfBlob *pubKeyBlob, HcfOpensslAlg2 return ret; } +/*HcfResult Convert25519PemKeyToKey(int type, const char *keyStr, int selection, EVP_PKEY *pkey) +{ + LOGE("[wjtest]Convert25519PemKeyToKey enter."); + + const char *inputType = "PEM"; + const char *keytype = NULL; + if (type == EVP_PKEY_ED25519) { + keytype = "ED25519"; + } + if (type == EVP_PKEY_X25519) { + keytype = "X25519"; + } + OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(&pkey, inputType, + NULL, keytype, selection, NULL, NULL); + if (ctx == NULL) { + LOGE("OpensslOsslDecoderCtxNewForPkey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + size_t pdataLen = strlen(keyStr); + const unsigned char *pdata = (const unsigned char *)keyStr; + int ret = OpensslOsslDecoderFromData(ctx, &pdata, &pdataLen); + OpensslOsslDecoderCtxFree(ctx); + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("OpensslOsslDecoderFromData failed."); + HcfPrintOpensslError(); + OpensslEvpPkeyFree(pkey); + return HCF_ERR_CRYPTO_OPERATION; + } + LOGE("[wjtest]Convert25519PemKeyToKey exit."); + return HCF_SUCCESS; +}*/ + +static HcfResult ConvertAlg25519PemPubKey(int type, const char *pubKeyStr, HcfOpensslAlg25519PubKey **returnPubKey) +{ + LOGE("[wjtest]ConvertAlg25519PemPubKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = NULL; + if (type == EVP_PKEY_ED25519) { + keyType = "ED25519"; + } + if (type == EVP_PKEY_X25519) { + keyType = "X25519"; + } + HcfResult ret = ConvertPemStrToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("Call ConvertPemKeyToKey fail."); + OpensslEvpPkeyFree(pkey); + return ret; + } + if (pkey == NULL) { + LOGE("[wjtest] ConvertAlg25519PemPubKey pkey is null ---1."); + } else { + LOGE("[wjtest] ConvertAlg25519PemPubKey pkey is not null ---1."); + } + ret = CreateAlg25519PubKey(pkey, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create alg25519 public key failed."); + OpensslEvpPkeyFree(pkey); + } + if (pkey == NULL) { + LOGE("[wjtest] ConvertAlg25519PemPubKey pkey is null ---2."); + } else { + LOGE("[wjtest] ConvertAlg25519PemPubKey pkey is not null ---2."); + } + LOGE("[wjtest]ConvertAlg25519PemPubKey exit."); + return ret; +} + static HcfResult ConvertAlg25519PriKey(int type, const HcfBlob *priKeyBlob, HcfOpensslAlg25519PriKey **returnPriKey) { @@ -656,6 +725,33 @@ static HcfResult ConvertAlg25519PriKey(int type, const HcfBlob *priKeyBlob, return ret; } +static HcfResult ConvertAlg25519PemPriKey(int type, const char *priKeyStr, + HcfOpensslAlg25519PriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertAlg25519PemPriKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = NULL; + if (type == EVP_PKEY_ED25519) { + keyType = "ED25519"; + } + if (type == EVP_PKEY_X25519) { + keyType = "X25519"; + } + HcfResult ret = ConvertPemStrToKey(priKeyStr, EVP_PKEY_KEYPAIR, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("Call ConvertPemKeyToKey fail."); + OpensslEvpPkeyFree(pkey); + return ret; + } + ret = CreateAlg25519PriKey(pkey, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create alg25519 private key failed."); + OpensslEvpPkeyFree(pkey); + } + LOGE("[wjtest]ConvertAlg25519PemPriKey exit."); + return ret; +} + static HcfResult ConvertAlg25519PubAndPriKey(int type, const HcfBlob *pubKeyBlob, const HcfBlob *priKeyBlob, HcfOpensslAlg25519PubKey **returnPubKey, HcfOpensslAlg25519PriKey **returnPriKey) { @@ -676,6 +772,28 @@ static HcfResult ConvertAlg25519PubAndPriKey(int type, const HcfBlob *pubKeyBlob return HCF_SUCCESS; } +static HcfResult ConvertAlg25519PemPubAndPriKey(int type, const char *pubKeyStr, const char *priKeyStr, + HcfOpensslAlg25519PubKey **returnPubKey, HcfOpensslAlg25519PriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertAlg25519PemPubAndPriKey enter."); + if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) { + if (ConvertAlg25519PemPubKey(type, pubKeyStr, returnPubKey) != HCF_SUCCESS) { + LOGE("Convert alg25519 pem public key failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + if (ConvertAlg25519PemPriKey(type, priKeyStr, returnPriKey) != HCF_SUCCESS) { + LOGE("Convert alg25519 pem private key failed."); + HcfObjDestroy(*returnPubKey); + *returnPubKey = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } + } + LOGE("[wjtest]ConvertAlg25519PemPubAndPriKey exit."); + return HCF_SUCCESS; +} + static HcfResult CheckClassMatch(HcfAsyKeyGeneratorSpi *self, int *type) { if (HcfIsClassMatch((HcfObjectBase *)self, GetEd25519KeyGeneratorSpiClass())) { @@ -774,6 +892,45 @@ static HcfResult EngineConvertAlg25519Key(HcfAsyKeyGeneratorSpi *self, HcfParams return ret; } +static HcfResult EngineConvertAlg25519PemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + LOGE("[wjtest]EngineConvertAlg25519PemKey enter."); + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + int type = 0; + if (CheckClassMatch(self, &type) != HCF_SUCCESS) { + LOGE("Invalid class of self."); + return HCF_INVALID_PARAMS; + } + + HcfOpensslAlg25519PubKey *pubKey = NULL; + HcfOpensslAlg25519PriKey *priKey = NULL; + HcfResult ret = ConvertAlg25519PemPubAndPriKey(type, pubKeyStr, priKeyStr, &pubKey, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("Convert alg25519 keyPair failed."); + return ret; + } + + if (pubKey != NULL) { + pubKey->type = type; + } + if (priKey != NULL) { + priKey->type = type; + } + ret = CreateAlg25519KeyPair(pubKey, priKey, returnKeyPair); + if (ret != HCF_SUCCESS) { + LOGE("Create alg25519 keyPair failed."); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + } + LOGE("[wjtest]EngineConvertAlg25519PemKey exit."); + return ret; +} + static HcfResult CreateOpensslAlg25519PubKey(const HcfBigInteger *pk, const char *algName, EVP_PKEY **returnAlg25519) { @@ -1012,6 +1169,7 @@ static HcfResult EngineGenerateAlg25519KeyPairBySpec(const HcfAsyKeyGeneratorSpi HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) { + LOGE("[wjtest] HcfAsyKeyGeneratorSpiEd25519Create enter."); (void)params; if (params == NULL || returnSpi == NULL) { LOGE("Invalid input parameter."); @@ -1027,16 +1185,19 @@ HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyK impl->base.base.destroy = DestroyAlg25519KeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateAlg25519KeyPair; impl->base.engineConvertKey = EngineConvertAlg25519Key; + impl->base.engineConvertPemKey = EngineConvertAlg25519PemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateAlg25519KeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + LOGE("[wjtest] HcfAsyKeyGeneratorSpiEd25519Create exit."); return HCF_SUCCESS; } HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) { + LOGE("[wjtest] HcfAsyKeyGeneratorSpiX25519Create enter."); (void)params; if (params == NULL || returnSpi == NULL) { LOGE("Invalid input parameter."); @@ -1052,11 +1213,13 @@ HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKe impl->base.base.destroy = DestroyAlg25519KeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateAlg25519KeyPair; impl->base.engineConvertKey = EngineConvertAlg25519Key; + impl->base.engineConvertPemKey = EngineConvertAlg25519PemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateAlg25519KeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + LOGE("[wjtest] HcfAsyKeyGeneratorSpiX25519Create exit."); return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/dh_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/dh_asy_key_generator_openssl.c index bc4be87..88bec78 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/dh_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/dh_asy_key_generator_openssl.c @@ -937,6 +937,93 @@ static HcfResult ConvertDhPubKey(const HcfBlob *pubKeyBlob, HcfOpensslDhPubKey * return ret; } +// static HcfResult ConvertDhPemKeyToKey(const char *keyStr, int selection, EVP_PKEY **pkey) +// { +// LOGE("[wjtest]ConvertDhPemKeyToKey enter."); +// const char *inputType = "PEM"; +// const char *keytype = "DH"; +// OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(pkey, inputType, +// NULL, keytype, selection, NULL, NULL); +// if (ctx == NULL) { +// LOGE("OpensslOsslDecoderCtxNewForPkey fail."); +// HcfPrintOpensslError(); +// return HCF_ERR_CRYPTO_OPERATION; +// } +// if (*pkey == NULL) { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is null ---1."); +// } else { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is not null ---1."); +// } +// size_t pdataLen = strlen(keyStr); +// const unsigned char *pdata = (const unsigned char *)keyStr; +// int ret = OpensslOsslDecoderFromData(ctx, &pdata, &pdataLen); +// if (*pkey == NULL) { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is null ---2."); +// } +// else { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is not null ---2."); +// } +// OpensslOsslDecoderCtxFree(ctx); +// if (*pkey == NULL) { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is null ---3."); +// } +// else { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is not null ---3."); +// } +// if (ret != HCF_OPENSSL_SUCCESS) { +// LOGE("OpensslOsslDecoderFromData failed."); +// HcfPrintOpensslError(); +// OpensslEvpPkeyFree(*pkey); +// return HCF_ERR_CRYPTO_OPERATION; +// } +// LOGE("[wjtest]ConvertDhPemKeyToKey exit."); +// if (*pkey == NULL) { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is null--4."); +// } +// else { +// LOGE("[wjtest]ConvertDhPemKeyToKey pkey is not null ---4."); +// } +// return HCF_SUCCESS; +// } + +static HcfResult ConvertDhPemPubKey(const char *pubKeyStr, HcfOpensslDhPubKey **returnPubKey) +{ + LOGE("[wjtest]ConvertDhPemPubKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "DH"; + HcfResult ret = ConvertPemStrToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, keyType, &pkey); + // HcfResult ret = ConvertDhPemKeyToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, &pKey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + if (pkey == NULL) { + LOGE("[wjtest]ConvertDhPemPubKey pkey is null."); + } else { + LOGE("[wjtest]ConvertDhPemPubKey pkey is not null."); + } + LOGE("[wjtest]ConvertDhPemPubKey ---1."); + DH *dh = OpensslEvpPkeyGet1Dh(pkey); + OpensslEvpPkeyFree(pkey); + LOGE("[wjtest]ConvertDhPemPubKey ---2."); + if (dh == NULL) { + LOGE("OpensslEvpPkeyGet1Dh failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + LOGE("[wjtest]ConvertDhPemPubKey ---3."); + LOGE("[wjtest]ConvertDhPemPubKey ---4."); + ret = CreateDhPubKey(dh, returnPubKey); + LOGE("[wjtest]ConvertDhPemPubKey ---5."); + if (ret != HCF_SUCCESS) { + LOGE("Create dh public key failed."); + OpensslDhFree(dh); + } + LOGE("[wjtest]ConvertDhPemPubKey exit."); + return ret; +} + static HcfResult ConvertDhPriKey(const HcfBlob *priKeyBlob, HcfOpensslDhPriKey **returnPriKey) { const unsigned char *temp = (const unsigned char *)priKeyBlob->data; @@ -962,6 +1049,33 @@ static HcfResult ConvertDhPriKey(const HcfBlob *priKeyBlob, HcfOpensslDhPriKey * return ret; } +static HcfResult ConvertDhPemPriKey(const char *priKeyStr, HcfOpensslDhPriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertDhPemPriKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "DH"; + HcfResult ret = ConvertPemStrToKey(priKeyStr, EVP_PKEY_KEYPAIR, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + DH *dh = OpensslEvpPkeyGet1Dh(pkey); + OpensslEvpPkeyFree(pkey); + if (dh == NULL) { + LOGE("OpensslEvpPkeyGet1Dh failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = CreateDhPriKey(dh, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create DH private key failed."); + OpensslDhFree(dh); + } + LOGE("[wjtest]ConvertDhPemPriKey exit."); + return ret; +} + static HcfResult ConvertDhPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob *priKeyBlob, HcfOpensslDhPubKey **returnPubKey, HcfOpensslDhPriKey **returnPriKey) { @@ -982,6 +1096,28 @@ static HcfResult ConvertDhPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob return HCF_SUCCESS; } +static HcfResult ConvertDhPemPubAndPriKey(const char *pubKeyStr, const char *priKeyStr, + HcfOpensslDhPubKey **returnPubKey, HcfOpensslDhPriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertDhPemPubAndPriKey enter."); + if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) { + if (ConvertDhPemPubKey(pubKeyStr, returnPubKey) != HCF_SUCCESS) { + LOGE("Convert DH pem public key failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + if (ConvertDhPemPriKey(priKeyStr, returnPriKey) != HCF_SUCCESS) { + LOGE("Convert DH pem private key failed."); + HcfObjDestroy(*returnPubKey); + *returnPubKey = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } + } + LOGE("[wjtest]ConvertDhPemPubAndPriKey exit."); + return HCF_SUCCESS; +} + static HcfResult EngineGenerateDhKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnKeyPair) { if (self == NULL || returnKeyPair == NULL) { @@ -1048,6 +1184,38 @@ static HcfResult EngineConvertDhKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec * return ret; } +static HcfResult EngineConvertDhPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + LOGE("[wjtest]EngineConvertDhPemKey enter."); + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, GetDhKeyGeneratorSpiClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + + HcfOpensslDhPubKey *pubKey = NULL; + HcfOpensslDhPriKey *priKey = NULL; + + HcfResult ret = ConvertDhPemPubAndPriKey(pubKeyStr, priKeyStr, &pubKey, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("Convert dh pem pubKey and priKey failed."); + return ret; + } + ret = CreateDhKeyPair(pubKey, priKey, returnKeyPair); + if (ret != HCF_SUCCESS) { + LOGE("Create dh keyPair failed."); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + } + LOGE("[wjtest]EngineConvertDhPemKey exit."); + return ret; +} + static HcfResult EngineGenerateDhKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { @@ -1140,6 +1308,7 @@ HcfResult HcfAsyKeyGeneratorSpiDhCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGen impl->base.base.destroy = DestroyDhKeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateDhKeyPair; impl->base.engineConvertKey = EngineConvertDhKey; + impl->base.engineConvertPemKey = EngineConvertDhPemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateDhKeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateDhPubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateDhPriKeyBySpec; diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/dsa_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/dsa_asy_key_generator_openssl.c index 9d862c1..0478ff3 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/dsa_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/dsa_asy_key_generator_openssl.c @@ -801,6 +801,60 @@ static HcfResult ConvertDsaPubKey(const HcfBlob *pubKeyBlob, HcfOpensslDsaPubKey return ret; } +// HcfResult ConvertDSAPemKeyToKey(const char *keyStr, int selection, EVP_PKEY *pkey) +// { +// LOGE("[wjtest]ConvertDSAPemKeyToKey enter."); +// const char *inputType = "PEM"; +// const char *keytype = "DSA"; +// OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(&pkey, inputType, +// NULL, keytype, selection, NULL, NULL); +// if (ctx == NULL) { +// LOGE("OpensslOsslDecoderCtxNewForPkey fail."); +// HcfPrintOpensslError(); +// return HCF_ERR_CRYPTO_OPERATION; +// } +// size_t pdataLen = strlen(keyStr); +// const unsigned char *pdata = (const unsigned char *)keyStr; +// int ret = OpensslOsslDecoderFromData(ctx, &pdata, &pdataLen); +// OpensslOsslDecoderCtxFree(ctx); +// if (ret != HCF_OPENSSL_SUCCESS) { +// LOGE("OpensslOsslDecoderFromData failed."); +// HcfPrintOpensslError(); +// OpensslEvpPkeyFree(pkey); +// return HCF_ERR_CRYPTO_OPERATION; +// } +// LOGE("[wjtest]ConvertDSAPemKeyToKey exit."); +// return HCF_SUCCESS; +// } + +static HcfResult ConvertDsaPemPubKey(const char *pubKeyStr, HcfOpensslDsaPubKey **returnPubKey) +{ + LOGE("[wjtest]ConvertDsaPemPubKey enter."); + EVP_PKEY *pkey = NULL; + //HcfResult ret = ConvertDSAPemKeyToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, pkey); + const char *keyType = "DSA"; + HcfResult ret = ConvertPemStrToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey); + OpensslEvpPkeyFree(pkey); + if (dsa == NULL) { + LOGE("OpensslEvpPkeyGet1Dsa fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = CreateDsaPubKey(dsa, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create DSA public key failed"); + OpensslDsaFree(dsa); + } + LOGE("[wjtest]ConvertDsaPemPubKey exit."); + return ret; +} + static HcfResult ConvertDsaPriKey(const HcfBlob *priKeyBlob, HcfOpensslDsaPriKey **returnPriKey) { const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data); @@ -818,6 +872,33 @@ static HcfResult ConvertDsaPriKey(const HcfBlob *priKeyBlob, HcfOpensslDsaPriKey return ret; } +static HcfResult ConvertDsaPemPriKey(const char *priKeyStr, HcfOpensslDsaPriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertDsaPemPriKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "DSA"; + HcfResult ret = ConvertPemStrToKey(priKeyStr, EVP_PKEY_KEYPAIR, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey); + OpensslEvpPkeyFree(pkey); + if (dsa == NULL) { + LOGE("OpensslEvpPkeyGet1Dsa fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = CreateDsaPriKey(dsa, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create DSA private key failed"); + OpensslDsaFree(dsa); + } + LOGE("[wjtest]ConvertDsaPemPriKey exit."); + return ret; +} + static HcfResult ConvertDsaPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob *priKeyBlob, HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey) { @@ -838,6 +919,28 @@ static HcfResult ConvertDsaPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob return HCF_SUCCESS; } +static HcfResult ConvertDsaPemPubAndPriKey(const char *pubKeyStr, const char *priKeyStr, + HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertDsaPemPubAndPriKey enter."); + if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) { + if (ConvertDsaPemPubKey(pubKeyStr, returnPubKey) != HCF_SUCCESS) { + LOGE("Convert DSA pem public key failed."); + return HCF_ERR_CRYPTO_OPERATION; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + if (ConvertDsaPemPriKey(priKeyStr, returnPriKey) != HCF_SUCCESS) { + LOGE("Convert DSA pem private key failed."); + HcfObjDestroy(*returnPubKey); + *returnPubKey = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } + } + LOGE("[wjtest]ConvertDsaPemPubAndPriKey exit."); + return HCF_SUCCESS; +} + static HcfResult EngineGenerateDsaKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnKeyPair) { if (self == NULL || returnKeyPair == NULL) { @@ -902,6 +1005,37 @@ static HcfResult EngineConvertDsaKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return ret; } +static HcfResult EngineConvertDsaPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + LOGE("[wjtest]EngineConvertDsaPemKey enter."); + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + + HcfOpensslDsaPubKey *pubKey = NULL; + HcfOpensslDsaPriKey *priKey = NULL; + + HcfResult ret = ConvertDsaPemPubAndPriKey(pubKeyStr, priKeyStr, &pubKey, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertDsaPemPubAndPriKey failed."); + return ret; + } + ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair); + if (ret != HCF_SUCCESS) { + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + } + LOGE("[wjtest]EngineConvertDsaPemKey exit."); + return ret; +} + static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { @@ -993,6 +1127,7 @@ HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGe impl->base.base.destroy = DestroyDsaKeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateDsaKeyPair; impl->base.engineConvertKey = EngineConvertDsaKey; + impl->base.engineConvertPemKey = EngineConvertDsaPemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateDsaKeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateDsaPubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateDsaPriKeyBySpec; 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 18e9d7e..81bc153 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 @@ -1726,6 +1726,68 @@ static HcfResult ConvertEcPubKey(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpenss return HCF_SUCCESS; } +/*static HcfResult ConvertEcPemKeyToKey(const char *keyStr, int selection, EC_KEY **ecKey) +{ + LOGE("[wjtest]ConvertEcPemKeyToKey enter."); + EVP_PKEY *pkey = NULL; + const char *inputType = "PEM"; + const char *keytype = "EC"; + OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(&pkey, inputType, + NULL, keytype, selection, NULL, NULL); + if (ctx == NULL) { + LOGE("OpensslOsslDecoderCtxNewForPkey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + size_t pdataLen = strlen(keyStr); + const unsigned char *pdata = (const unsigned char *)keyStr; + int ret = OpensslOsslDecoderFromData(ctx, &pdata, &pdataLen); + OpensslOsslDecoderCtxFree(ctx); + if (ret != HCF_OPENSSL_SUCCESS) { + LOGE("OpensslOsslDecoderFromData failed."); + HcfPrintOpensslError(); + OpensslEvpPkeyFree(pkey); + return HCF_ERR_CRYPTO_OPERATION; + } + *ecKey = OpensslEvpPkeyGet1EcKey(pkey); + OpensslEvpPkeyFree(pkey); + if (*ecKey == NULL) { + LOGE("OpensslEvpPkeyGet1EcKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + LOGE("[wjtest]ConvertEcPemKeyToKey exit."); + return HCF_SUCCESS; +}*/ + +static HcfResult ConvertEcPemPubKey(int32_t curveId, const char *pubKeyStr, HcfOpensslEccPubKey **returnPubKey) +{ + LOGE("[wjtest]ConvertEcPemPubKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "EC"; + HcfResult ret = ConvertPemStrToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + EC_KEY *ecKey = OpensslEvpPkeyGet1EcKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("OpensslEvpPkeyGet1EcKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + HcfResult res = PackEccPubKey(curveId, ecKey, g_eccGenerateFieldType, returnPubKey); + if (res != HCF_SUCCESS) { + LOGE("PackEccPubKey failed."); + OpensslEcKeyFree(ecKey); + return res; + } + LOGE("[wjtest]ConvertEcPemPubKey exit."); + return HCF_SUCCESS; +} + static HcfResult ConvertPriFromEncoded(EC_KEY **eckey, HcfBlob *priKeyBlob) { const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data); @@ -1768,6 +1830,34 @@ static HcfResult ConvertEcPriKey(int32_t curveId, HcfBlob *priKeyBlob, HcfOpenss return HCF_SUCCESS; } +static HcfResult ConvertEcPemPriKey(int32_t curveId, const char *priKeyStr, HcfOpensslEccPriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertEcPemPriKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "EC"; + HcfResult ret = ConvertPemStrToKey(priKeyStr, EVP_PKEY_KEYPAIR, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + EC_KEY *ecKey = OpensslEvpPkeyGet1EcKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("OpensslEvpPkeyGet1EcKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = PackEccPriKey(curveId, ecKey, g_eccGenerateFieldType, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Pack ec pri key failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + LOGE("[wjtest]ConvertEcPemPriKey exit."); + return HCF_SUCCESS; +} + static HcfResult EngineConvertEccKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob, HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair) { @@ -1816,6 +1906,50 @@ static HcfResult EngineConvertEccKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return HCF_SUCCESS; } +static HcfResult EngineConvertEccPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + LOGE("[wjtest]EngineConvertEccPemKey enter."); + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, GetEccKeyPairGeneratorClass())) { + return HCF_INVALID_PARAMS; + } + + HcfAsyKeyGeneratorSpiOpensslEccImpl *impl = (HcfAsyKeyGeneratorSpiOpensslEccImpl *)self; + HcfResult res = HCF_SUCCESS; + HcfOpensslEccPubKey *pubKey = NULL; + HcfOpensslEccPriKey *priKey = NULL; + HcfOpensslEccKeyPair *keyPair = NULL; + do { + if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) { + res = ConvertEcPemPubKey(impl->curveId, pubKeyStr, &pubKey); + if (res != HCF_SUCCESS) { + break; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + res = ConvertEcPemPriKey(impl->curveId, priKeyStr, &priKey); + if (res != HCF_SUCCESS) { + break; + } + } + res = PackEccKeyPair(pubKey, priKey, &keyPair); + } while (0); + if (res != HCF_SUCCESS) { + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + return res; + } + + *returnKeyPair = (HcfKeyPair *)keyPair; + LOGE("[wjtest]EngineConvertEccPemKey exit."); + return HCF_SUCCESS; +} + static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslEccImpl *impl, const char *fieldType, EC_KEY *ecKey, HcfPubKey **returnObj) { @@ -2032,6 +2166,7 @@ HcfResult HcfAsyKeyGeneratorSpiEccCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGe returnImpl->base.base.getClass = GetEccKeyPairGeneratorClass; returnImpl->base.base.destroy = DestroyEccKeyPairGenerator; returnImpl->base.engineConvertKey = EngineConvertEccKey; + returnImpl->base.engineConvertPemKey = EngineConvertEccPemKey; returnImpl->base.engineGenerateKeyPair = EngineGenerateKeyPair; returnImpl->base.engineGenerateKeyPairBySpec = EngineGenerateKeyPairBySpec; returnImpl->base.engineGeneratePubKeyBySpec = EngineGeneratePubKeyBySpec; diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c index 675c893..0398204 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/sm2_asy_key_generator_openssl.c @@ -874,6 +874,125 @@ static HcfResult ConvertEcPubKey(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpenss return HCF_SUCCESS; } +static EC_KEY *GetSm2EckeyformPubKey(EVP_PKEY *pkey) +{ + LOGE("[wjtest]GetSm2EckeyformPubKey enter."); + EC_KEY *ecKey = NULL; + const EC_GROUP *group = NULL; + EC_POINT *pubPoint = NULL; + unsigned char OutPubKey[80]; + size_t outPubKeyLen = 0; + if (!OpensslEvpPkeyIsA(pkey, "SM2")) { + LOGE("pkey is not a sm2."); + return NULL; + } + ecKey = OpensslEcKeyNewbyCurveNameEX(NULL, NULL, NID_sm2); + if (ecKey == NULL) { + LOGE("OpensslEcKeyNewbyCurveNameEX failed."); + return NULL; + } + group = OpensslEcKeyGet0Group(ecKey); + if (group == NULL) { + LOGE("OpensslEcKeyGet0Group failed."); + OpensslEcKeyFree(ecKey); + return NULL; + } + pubPoint = OpensslEcPointNew(group); + if (pubPoint == NULL) { + LOGE("OpensslEcPointNew."); + OpensslEcKeyFree(ecKey); + return NULL; + } + if (!OpensslEvpPkeyGetOctetStringParam(pkey, OSSL_PKEY_PARAM_PUB_KEY, + OutPubKey, sizeof(OutPubKey), &outPubKeyLen)) { + LOGE("OpensslEvpPkeyGetOctetStringParam failed."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + if (!OpensslEcOct2Point(group, pubPoint, OutPubKey, outPubKeyLen, NULL)) { + LOGE("Failed to convet public key."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + OpensslEcKeySetFlags(ecKey, EC_FLAG_SM2_RANGE); + if (!OpensslEcKeySetPublicKey(ecKey, pubPoint)) { + LOGE("OpensslEcKeySetPublicKey."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + OpensslEcPointFree(pubPoint); + LOGE("[wjtest]GetSm2EckeyformPubKey exit."); + return ecKey; +} + +static EC_KEY *GetSm2EckeyformPriKey(EVP_PKEY *pkey) +{ + LOGE("[wjtest]GetSm2EckeyformPriKey enter."); + EC_KEY *ecKey = NULL; + BIGNUM *outPriv = NULL; + if (!OpensslEvpPkeyIsA(pkey, "SM2")) { + LOGE("pkey is not a sm2."); + return NULL; + } + ecKey = OpensslEcKeyNewbyCurveNameEX(NULL, NULL, NID_sm2); + if (ecKey == NULL) { + LOGE("OpensslEcKeyNewbyCurveNameEX failed."); + return NULL; + } + if(OpensslEvpPkeyGetBnParam(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &outPriv) != 1) { + LOGE("Failed to get private key."); + OpensslEcKeyFree(ecKey); + return NULL; + } + OpensslEcKeySetFlags(ecKey, EC_FLAG_SM2_RANGE); + if (!OpensslEcKeySetPrivateKey(ecKey, outPriv)) { + LOGE("OpensslEcKeySetPrivateKey failed."); + OpensslEcKeyFree(ecKey); + OpensslBnClearFree(outPriv); + return NULL; + } + OpensslBnClearFree(outPriv); + LOGE("[wjtest]GetSm2EckeyformPriKey exit."); + return ecKey; +} + +static HcfResult ConvertSM2PemPubKey(int32_t curveId, const char *pubKeyStr, HcfOpensslSm2PubKey **returnPubKey) +{ + LOGE("[wjtest]ConvertSM2PemPubKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "SM2"; + LOGE("[wjtest]ConvertSM2PemPubKey keyType = %s.", keyType); + HcfResult ret = ConvertPemStrToKey(pubKeyStr, EVP_PKEY_PUBLIC_KEY, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + if (pkey == NULL) { + LOGE("[wjtest]ConvertSM2PemPubKey pkey is null."); + } else { + LOGE("[wjtest]ConvertSM2PemPubKey pkey is not null."); + } + EC_KEY *ecKey = GetSm2EckeyformPubKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("GetSm2EckeyformPubKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = PackSm2PubKey(curveId, ecKey, g_sm2GenerateFieldType, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("PackSm2PubKey failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + LOGE("[wjtest]ConvertSM2PemPubKey exit."); + return HCF_SUCCESS; +} + static HcfResult ConvertEcPriKey(int32_t curveId, HcfBlob *priKeyBlob, HcfOpensslSm2PriKey **returnPriKey) { const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data); @@ -892,6 +1011,35 @@ static HcfResult ConvertEcPriKey(int32_t curveId, HcfBlob *priKeyBlob, HcfOpenss return HCF_SUCCESS; } +static HcfResult ConvertSM2PemPriKey(int32_t curveId, const char *priKeyStr, HcfOpensslSm2PriKey **returnPriKey) +{ + LOGE("[wjtest]ConvertSM2PemPriKey enter."); + EVP_PKEY *pkey = NULL; + const char *keyType = "SM2"; + LOGE("[wjtest]ConvertSM2PemPriKey keyType = %s.", keyType); + HcfResult ret = ConvertPemStrToKey(priKeyStr, EVP_PKEY_KEYPAIR, keyType, &pkey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertPemStrToKey failed."); + OpensslEvpPkeyFree(pkey); + return ret; + } + EC_KEY *ecKey = GetSm2EckeyformPriKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("OpensslEvpPkeyGet1EcKey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + ret = PackSm2PriKey(curveId, ecKey, g_sm2GenerateFieldType, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("PackSm2PriKey failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + LOGE("[wjtest]ConvertSM2PemPriKey exit."); + return HCF_SUCCESS; +} + static HcfResult EngineConvertSm2Key(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob, HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair) { @@ -944,6 +1092,54 @@ static HcfResult EngineConvertSm2Key(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return HCF_SUCCESS; } +static HcfResult EngineConvertSm2PemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + LOGE("[wjtest]EngineConvertSm2PemKey enter."); + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, self->base.getClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + + HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self; + HcfResult ret = HCF_SUCCESS; + HcfOpensslSm2PubKey *pubKey = NULL; + HcfOpensslSm2PriKey *priKey = NULL; + HcfOpensslSm2KeyPair *keyPair = NULL; + do { + if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) { + ret = ConvertSM2PemPubKey(impl->curveId, pubKeyStr, &pubKey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertEcPemPubKey failed."); + break; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + ret = ConvertSM2PemPriKey(impl->curveId, priKeyStr, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("ConvertEcPemPriKey failed."); + break; + } + } + ret = PackSm2KeyPair(pubKey, priKey, &keyPair); + } while (0); + if (ret != HCF_SUCCESS) { + LOGE("Convert sm2 keyPair failed."); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + return ret; + } + + *returnKeyPair = (HcfKeyPair *)keyPair; + LOGE("[wjtest]EngineConvertSm2PemKey exit."); + return HCF_SUCCESS; +} + static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType, EC_KEY *ecKey, HcfPubKey **returnObj) { @@ -1159,6 +1355,7 @@ HcfResult HcfAsyKeyGeneratorSpiSm2Create(HcfAsyKeyGenParams *params, HcfAsyKeyGe returnImpl->base.base.getClass = GetSm2KeyPairGeneratorClass; returnImpl->base.base.destroy = DestroySm2KeyPairGenerator; returnImpl->base.engineConvertKey = EngineConvertSm2Key; + returnImpl->base.engineConvertPemKey = EngineConvertSm2PemKey; returnImpl->base.engineGenerateKeyPair = EngineGenerateKeyPair; returnImpl->base.engineGenerateKeyPairBySpec = EngineGenerateKeyPairBySpec; returnImpl->base.engineGeneratePubKeyBySpec = EngineGeneratePubKeyBySpec; -- Gitee