From cc8ac33bda3749b5bd2e0f6d699fbbe009e8265c Mon Sep 17 00:00:00 2001 From: hhhFun Date: Thu, 8 Aug 2024 20:50:31 +0800 Subject: [PATCH 01/32] =?UTF-8?q?=E6=8F=90=E4=BE=9B=E6=94=AF=E6=8C=81?= =?UTF-8?q?=E5=A4=96=E9=83=A8PEM=E5=BD=A2=E5=BC=8F=E5=AF=86=E9=92=A5?= =?UTF-8?q?=E6=95=B0=E6=8D=AE=E8=BD=AC=E6=8D=A2=E6=88=90=E7=AE=97=E6=B3=95?= =?UTF-8?q?=E5=BA=93=E5=AF=86=E9=92=A5=E5=AF=B9=E8=B1=A1=E8=83=BD=E5=8A=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- .../common/inc/openssl_adapter.h | 12 ++ .../common/inc/openssl_common.h | 4 + .../common/src/openssl_adapter.c | 36 ++++ .../common/src/openssl_common.c | 53 +++++ .../src/alg_25519_asy_key_generator_openssl.c | 149 ++++++++++++++ .../src/dh_asy_key_generator_openssl.c | 109 ++++++++++ .../src/dsa_asy_key_generator_openssl.c | 105 ++++++++++ .../src/ecc_asy_key_generator_openssl.c | 101 ++++++++++ .../src/sm2_asy_key_generator_openssl.c | 189 ++++++++++++++++++ 9 files changed, 758 insertions(+) diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h index 5ad1a69..ab212bc 100644 --- a/plugin/openssl_plugin/common/inc/openssl_adapter.h +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -28,6 +28,8 @@ #include #include #include +#include +#include #include #include @@ -217,9 +219,12 @@ int OpensslEvpPkeySet1Rsa(EVP_PKEY *pkey, struct rsa_st *key); int OpensslEvpPkeyAssignRsa(EVP_PKEY *pkey, struct rsa_st *key); int OpensslPemWriteBioRsaPublicKey(BIO *bp, RSA *x); int OpensslPemWriteBioRsaPubKey(BIO *bp, RSA *x); +EVP_PKEY *OpensslPemReadBioPrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u); + // BIO BIO *OpensslBioNew(const BIO_METHOD *type); const BIO_METHOD *OpensslBioSMem(void); +int OpensslBioWrite(BIO *b, const void *data, int dlen); int OpensslBioRead(BIO *b, void *data, int dlen); void OpensslBioFreeAll(BIO *a); @@ -325,6 +330,7 @@ const BIGNUM *OpensslDhGet0PrivKey(const DH *dh); int OpensslEvpPkeySet1Dh(EVP_PKEY *pkey, DH *key); int OpensslEvpPkeyAssignDh(EVP_PKEY *pkey, DH *key); struct dh_st *OpensslEvpPkeyGet1Dh(EVP_PKEY *pkey); +int OpensslEvpPkeyIsA(const EVP_PKEY *pkey, const char *name); int OpensslEvpPkeyCtxSetDhParamgenPrimeLen(EVP_PKEY_CTX *ctx, int pbits); int OpensslEvpPkeyCtxSetSignatureMd(EVP_PKEY_CTX *ctx, const EVP_MD *md); int OpensslDhUpRef(DH *r); @@ -383,6 +389,12 @@ 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); +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..7607bbe 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -70,6 +70,10 @@ HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret); HcfResult GetKeyEncodedPem(EVP_PKEY *pkey, const char *outPutStruct, int selection, char **returnString); +HcfResult ConvertPubPemStrToKey(EVP_PKEY **pkey, const char *keyType, int selection, const char *keyStr); + +HcfResult ConvertPriPemStrToKey(const char *keyStr, EVP_PKEY **pkey, const char *keyType); + #ifdef __cplusplus } #endif diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c index 8760c91..48a9fbc 100644 --- a/plugin/openssl_plugin/common/src/openssl_adapter.c +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -819,6 +819,11 @@ int OpensslPemWriteBioRsaPubKey(BIO *bp, RSA *x) return PEM_write_bio_RSA_PUBKEY(bp, x); } +EVP_PKEY *OpensslPemReadBioPrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u) +{ + return PEM_read_bio_PrivateKey(bp, x, cb, u); +} + BIO *OpensslBioNew(const BIO_METHOD *type) { return BIO_new(type); @@ -834,6 +839,11 @@ int OpensslBioRead(BIO *b, void *data, int dlen) return BIO_read(b, data, dlen); } +int OpensslBioWrite(BIO *b, const void *data, int dlen) +{ + return BIO_write(b, data, dlen); +} + void OpensslBioFreeAll(BIO *a) { return BIO_free_all(a); @@ -1278,6 +1288,11 @@ DH *OpensslEvpPkeyGet1Dh(EVP_PKEY *pkey) return EVP_PKEY_get1_DH(pkey); } +int OpensslEvpPkeyIsA(const EVP_PKEY *pkey, const char *name) +{ + return EVP_PKEY_is_a(pkey, name); +} + int OpensslEvpPkeyAssignDh(EVP_PKEY *pkey, DH *key) { return EVP_PKEY_assign_DH(pkey, key); @@ -1479,3 +1494,24 @@ void OpensslOsslDecoderCtxFree(OSSL_DECODER_CTX *ctx) { OSSL_DECODER_CTX_free(ctx); } + +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..275cf33 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -577,3 +577,56 @@ HcfResult GetKeyEncodedPem(EVP_PKEY *pkey, const char *outPutStruct, int selecti OpensslOsslEncoderCtxFree(ctx); return HCF_SUCCESS; } + +HcfResult ConvertPubPemStrToKey(EVP_PKEY **pkey, const char *keyType, int selection, const char *keyStr) +{ + OSSL_DECODER_CTX *ctx = OpensslOsslDecoderCtxNewForPkey(pkey, "PEM", NULL, keyType, selection, NULL, NULL); + if (ctx == NULL) { + LOGE("Failed to init pem public key decoder ctx."); + 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("Failed to decode public key from pem data."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + return HCF_SUCCESS; +} + +HcfResult ConvertPriPemStrToKey(const char *keyStr, EVP_PKEY **pkey, const char *keyType) +{ + BIO *bio = OpensslBioNew(OpensslBioSMem()); + if (bio == NULL) { + LOGE("Failed to init bio."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (OpensslBioWrite(bio, keyStr, strlen(keyStr)) <= 0) { + OpensslBioFreeAll(bio); + LOGE("Failed to write pem private key to bio"); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + EVP_PKEY *pkeyRet = OpensslPemReadBioPrivateKey(bio, pkey, NULL, NULL); + OpensslBioFreeAll(bio); + if (pkeyRet == NULL) { + LOGE("Failed to read private key from bio"); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + if (OpensslEvpPkeyIsA(*pkey, keyType) != HCF_OPENSSL_SUCCESS) { + LOGE("Private key type does not match current alg [%s].", keyType); + OpensslEvpPkeyFree(*pkey); + return HCF_INVALID_PARAMS; + } + + return HCF_SUCCESS; +} 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..759173f 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 @@ -774,6 +774,153 @@ static HcfResult EngineConvertAlg25519Key(HcfAsyKeyGeneratorSpi *self, HcfParams return ret; } +static HcfResult ConvertAlg25519PemPubKey(int type, const char *pubKeyStr, HcfOpensslAlg25519PubKey **returnPubKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = NULL; + if (type == EVP_PKEY_ED25519) { + keyType = "ED25519"; + } + if (type == EVP_PKEY_X25519) { + keyType = "X25519"; + } + + HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr); + if (ret != HCF_SUCCESS) { + LOGE("Convert public key from pem to key failed."); + return ret; + } + + ret = CreateAlg25519PubKey(pkey, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create alg25519 public key failed."); + OpensslEvpPkeyFree(pkey); + } + + return ret; +} + +static HcfResult ConvertAlg25519PemPriKey(int type, const char *priKeyStr, HcfOpensslAlg25519PriKey **returnPriKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = NULL; + if (type == EVP_PKEY_ED25519) { + keyType = "ED25519"; + } + if (type == EVP_PKEY_X25519) { + keyType = "X25519"; + } + + HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType); + if (ret != HCF_SUCCESS) { + LOGE("Convert private key from pem to key failed."); + return ret; + } + + ret = CreateAlg25519PriKey(pkey, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create alg25519 private key failed."); + OpensslEvpPkeyFree(pkey); + } + return ret; +} + +static HcfResult ConvertAlg25519PemPubAndPriKey(int type, const char *pubKeyStr, const char *priKeyStr, + HcfOpensslAlg25519PubKey **returnPubKey, HcfOpensslAlg25519PriKey **returnPriKey) +{ + 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; + } + } + return HCF_SUCCESS; +} + +static HcfResult EngineConvertX25519PemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + + if (!HcfIsClassMatch((HcfObjectBase *)self, GetX25519KeyGeneratorSpiClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + + HcfOpensslAlg25519PubKey *pubKey = NULL; + HcfOpensslAlg25519PriKey *priKey = NULL; + int type = EVP_PKEY_X25519; + HcfResult ret = ConvertAlg25519PemPubAndPriKey(type, pubKeyStr, priKeyStr, &pubKey, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("Convert alg25519 pem 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); + } + return ret; +} + +static HcfResult EngineConvertEd25519PemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (void)params; + if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + + if (!HcfIsClassMatch((HcfObjectBase *)self, GetEd25519KeyGeneratorSpiClass())) { + LOGE("Class not match."); + return HCF_INVALID_PARAMS; + } + + HcfOpensslAlg25519PubKey *pubKey = NULL; + HcfOpensslAlg25519PriKey *priKey = NULL; + int type = EVP_PKEY_ED25519; + HcfResult ret = ConvertAlg25519PemPubAndPriKey(type, pubKeyStr, priKeyStr, &pubKey, &priKey); + if (ret != HCF_SUCCESS) { + LOGE("Convert alg25519 pem 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); + } + return ret; +} + static HcfResult CreateOpensslAlg25519PubKey(const HcfBigInteger *pk, const char *algName, EVP_PKEY **returnAlg25519) { @@ -1027,6 +1174,7 @@ HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyK impl->base.base.destroy = DestroyAlg25519KeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateAlg25519KeyPair; impl->base.engineConvertKey = EngineConvertAlg25519Key; + impl->base.engineConvertPemKey = EngineConvertEd25519PemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateAlg25519KeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; @@ -1052,6 +1200,7 @@ HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKe impl->base.base.destroy = DestroyAlg25519KeyGeneratorSpiImpl; impl->base.engineGenerateKeyPair = EngineGenerateAlg25519KeyPair; impl->base.engineConvertKey = EngineConvertAlg25519Key; + impl->base.engineConvertPemKey = EngineConvertX25519PemKey; impl->base.engineGenerateKeyPairBySpec = EngineGenerateAlg25519KeyPairBySpec; impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; 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..6e0083f 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 @@ -1048,6 +1048,114 @@ static HcfResult EngineConvertDhKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec * return ret; } +static HcfResult ConvertDhPemPubKey(const char *pubKeyStr, HcfOpensslDhPubKey **returnPubKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "DH"; + HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr); + if (ret != HCF_SUCCESS) { + LOGE("Convert dh pem public key failed."); + return ret; + } + + DH *dh = OpensslEvpPkeyGet1Dh(pkey); + OpensslEvpPkeyFree(pkey); + if (dh == NULL) { + LOGE("Pkey to dh key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = CreateDhPubKey(dh, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create dh public key failed."); + OpensslDhFree(dh); + } + + return ret; +} + +static HcfResult ConvertDhPemPriKey(const char *priKeyStr, HcfOpensslDhPriKey **returnPriKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "DH"; + HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType); + if (ret != HCF_SUCCESS) { + LOGE("Convert dh pem private key failed."); + return ret; + } + + DH *dh = OpensslEvpPkeyGet1Dh(pkey); + OpensslEvpPkeyFree(pkey); + if (dh == NULL) { + LOGE("Pkey to dh key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = CreateDhPriKey(dh, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create DH private key failed."); + OpensslDhFree(dh); + } + + return ret; +} + +static HcfResult ConvertDhPemPubAndPriKey(const char *pubKeyStr, const char *priKeyStr, + HcfOpensslDhPubKey **returnPubKey, HcfOpensslDhPriKey **returnPriKey) +{ + 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; + } + } + + return HCF_SUCCESS; +} + +static HcfResult EngineConvertDhPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (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); + } + + return ret; +} + static HcfResult EngineGenerateDhKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { @@ -1140,6 +1248,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 452d79a..8d7e8a2 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 @@ -902,6 +902,110 @@ static HcfResult EngineConvertDsaKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return ret; } +static HcfResult ConvertDsaPemPubKey(const char *pubKeyStr, HcfOpensslDsaPubKey **returnPubKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "DSA"; + HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr); + if (ret != HCF_SUCCESS) { + LOGE("Convert dsa pem public key failed."); + return ret; + } + + DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey); + OpensslEvpPkeyFree(pkey); + if (dsa == NULL) { + LOGE("Pkey to dsa key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = CreateDsaPubKey(dsa, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create dsa public key failed"); + OpensslDsaFree(dsa); + } + return ret; +} + +static HcfResult ConvertDsaPemPriKey(const char *priKeyStr, HcfOpensslDsaPriKey **returnPriKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "DSA"; + HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType); + if (ret != HCF_SUCCESS) { + LOGE("Convert dsa pem private key failed."); + return ret; + } + + DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey); + OpensslEvpPkeyFree(pkey); + if (dsa == NULL) { + LOGE("Pkey to dsa key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = CreateDsaPriKey(dsa, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create dsa private key failed"); + OpensslDsaFree(dsa); + } + + return ret; +} + +static HcfResult ConvertDsaPemPubAndPriKey(const char *pubKeyStr, const char *priKeyStr, + HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey) +{ + 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; + } + } + return HCF_SUCCESS; +} + +static HcfResult EngineConvertDsaPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (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) { + return ret; + } + + ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair); + if (ret != HCF_SUCCESS) { + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + } + + return ret; +} + static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { @@ -993,6 +1097,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 4939a42..e2c8c8d 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 @@ -1816,6 +1816,106 @@ static HcfResult EngineConvertEccKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return HCF_SUCCESS; } +static HcfResult ConvertEcPemPubKey(int32_t curveId, const char *pubKeyStr, HcfOpensslEccPubKey **returnPubKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "EC"; + HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr); + if (ret != HCF_SUCCESS) { + LOGE("Convert ecc pem public key failed."); + return ret; + } + + EC_KEY *ecKey = OpensslEvpPkeyGet1EcKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("Pkey to ec key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + HcfResult res = PackEccPubKey(curveId, ecKey, g_eccGenerateFieldType, returnPubKey); + if (res != HCF_SUCCESS) { + LOGE("Pack ec public key failed."); + OpensslEcKeyFree(ecKey); + return res; + } + + return HCF_SUCCESS; +} + +static HcfResult ConvertEcPemPriKey(int32_t curveId, const char *priKeyStr, HcfOpensslEccPriKey **returnPriKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "EC"; + HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType); + if (ret != HCF_SUCCESS) { + LOGE("Convert ecc pem private key failed."); + return ret; + } + + EC_KEY *ecKey = OpensslEvpPkeyGet1EcKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("Pkey to ec key failed."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = PackEccPriKey(curveId, ecKey, g_eccGenerateFieldType, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Pack ec private key failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + + return HCF_SUCCESS; +} + +static HcfResult EngineConvertEccPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (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) { + LOGE("Convert ec keyPair failed."); + HcfObjDestroy(pubKey); + HcfObjDestroy(priKey); + return res; + } + + *returnKeyPair = (HcfKeyPair *)keyPair; + return HCF_SUCCESS; +} + static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslEccImpl *impl, const char *fieldType, EC_KEY *ecKey, HcfPubKey **returnObj) { @@ -2032,6 +2132,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..35d5191 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 @@ -27,6 +27,9 @@ #define OPENSSL_SM2_ALGORITHM "SM2" #define OPENSSL_SM2_PUB_KEY_FORMAT "X.509" #define OPENSSL_SM2_PRI_KEY_FORMAT "PKCS#8" + +#define SM2_OCTET_STRING_LEN 65 // strlen(0x04) + strlen(X) + strlen(Y): 1 + 32 + 32 + static const char *const g_sm2GenerateFieldType = "Fp"; typedef struct { @@ -944,6 +947,191 @@ static HcfResult EngineConvertSm2Key(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec return HCF_SUCCESS; } +static EC_KEY *GetSm2EckeyformPubKey(const EVP_PKEY *pkey) +{ + EC_KEY *ecKey = NULL; + const EC_GROUP *group = NULL; + EC_POINT *pubPoint = NULL; + unsigned char octetKey[SM2_OCTET_STRING_LEN]; + size_t octetKeyLen = 0; + + ecKey = OpensslEcKeyNewbyCurveNameEx(NULL, NULL, NID_sm2); + if (ecKey == NULL) { + LOGE("Failed to init ec key."); + return NULL; + } + + group = OpensslEcKeyGet0Group(ecKey); + if (group == NULL) { + LOGE("Failed to get group while get ec key."); + OpensslEcKeyFree(ecKey); + return NULL; + } + + pubPoint = OpensslEcPointNew(group); + if (pubPoint == NULL) { + LOGE("Failed to init ec point while get ec key."); + OpensslEcKeyFree(ecKey); + return NULL; + } + + if (!OpensslEvpPkeyGetOctetStringParam(pkey, OSSL_PKEY_PARAM_PUB_KEY, octetKey, sizeof(octetKey), + &octetKeyLen)) { + LOGE("Failed to get octet string param while get ec key."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + + if (!OpensslEcOct2Point(group, pubPoint, octetKey, octetKeyLen, NULL)) { + LOGE("Failed to convert oct to point while get ec key."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + + OpensslEcKeySetFlags(ecKey, EC_FLAG_SM2_RANGE); + if (!OpensslEcKeySetPublicKey(ecKey, pubPoint)) { + LOGE("Failed to set public key while get ec key."); + OpensslEcKeyFree(ecKey); + OpensslEcPointFree(pubPoint); + return NULL; + } + OpensslEcPointFree(pubPoint); + + return ecKey; +} + +static EC_KEY *GetSm2EckeyformPriKey(const EVP_PKEY *pkey) +{ + EC_KEY *ecKey = NULL; + BIGNUM *outPriv = NULL; + + ecKey = OpensslEcKeyNewbyCurveNameEx(NULL, NULL, NID_sm2); + if (ecKey == NULL) { + LOGE("Failed to init ec key."); + return NULL; + } + + if (OpensslEvpPkeyGetBnParam(pkey, OSSL_PKEY_PARAM_PRIV_KEY, &outPriv) != HCF_OPENSSL_SUCCESS) { + LOGE("Failed to get bn param while get ec key."); + OpensslEcKeyFree(ecKey); + return NULL; + } + + OpensslEcKeySetFlags(ecKey, EC_FLAG_SM2_RANGE); + if (OpensslEcKeySetPrivateKey(ecKey, outPriv) != HCF_OPENSSL_SUCCESS) { + LOGE("Failed to set private key while get ec key."); + OpensslEcKeyFree(ecKey); + OpensslBnClearFree(outPriv); + return NULL; + } + OpensslBnClearFree(outPriv); + + return ecKey; +} + +static HcfResult ConvertSM2PemPubKey(int32_t curveId, const char *pubKeyStr, HcfOpensslSm2PubKey **returnPubKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "SM2"; + HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr); + if (ret != HCF_SUCCESS) { + LOGE("Convert sm2 pem public key failed."); + return ret; + } + + EC_KEY *ecKey = GetSm2EckeyformPubKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("Get sm2 ec pkey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = PackSm2PubKey(curveId, ecKey, g_sm2GenerateFieldType, returnPubKey); + if (ret != HCF_SUCCESS) { + LOGE("Create sm2 public key failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + + return HCF_SUCCESS; +} + +static HcfResult ConvertSM2PemPriKey(int32_t curveId, const char *priKeyStr, HcfOpensslSm2PriKey **returnPriKey) +{ + EVP_PKEY *pkey = NULL; + const char *keyType = "SM2"; + HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType); + if (ret != HCF_SUCCESS) { + LOGE("Convert sm2 pem private key failed."); + return ret; + } + + EC_KEY *ecKey = GetSm2EckeyformPriKey(pkey); + OpensslEvpPkeyFree(pkey); + if (ecKey == NULL) { + LOGE("Get sm2 ec pkey fail."); + HcfPrintOpensslError(); + return HCF_ERR_CRYPTO_OPERATION; + } + + ret = PackSm2PriKey(curveId, ecKey, g_sm2GenerateFieldType, returnPriKey); + if (ret != HCF_SUCCESS) { + LOGE("Create sm2 private key failed."); + OpensslEcKeyFree(ecKey); + return ret; + } + + return HCF_SUCCESS; +} + +static HcfResult EngineConvertSm2PemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr, + const char *priKeyStr, HcfKeyPair **returnKeyPair) +{ + (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) { + break; + } + } + if (priKeyStr != NULL && strlen(priKeyStr) != 0) { + ret = ConvertSM2PemPriKey(impl->curveId, priKeyStr, &priKey); + if (ret != HCF_SUCCESS) { + 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; + return HCF_SUCCESS; +} + static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType, EC_KEY *ecKey, HcfPubKey **returnObj) { @@ -1159,6 +1347,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 From 3c10c581f469301a9c97975766a091952c261fd4 Mon Sep 17 00:00:00 2001 From: hhhFun Date: Fri, 9 Aug 2024 02:11:31 +0800 Subject: [PATCH 02/32] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=8F=90=E4=BE=9B?= =?UTF-8?q?=E6=94=AF=E6=8C=81=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?= =?UTF-8?q?=E8=83=BD=E5=8A=9BTDD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- test/unittest/BUILD.gn | 1 + .../src/crypto_asy_key_convert_pem_test.cpp | 1084 +++++++++++++++++ 2 files changed, 1085 insertions(+) create mode 100644 test/unittest/src/crypto_asy_key_convert_pem_test.cpp diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 9e6a971..dedf2d2 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -43,6 +43,7 @@ ohos_unittest("crypto_framework_test") { "src/aes_cipher/crypto_aes_gcm_cipher_test.cpp", "src/aes_cipher/crypto_aes_ofb_cipher_test.cpp", "src/crypto_3des_cipher_test.cpp", + "src/crypto_asy_key_convert_pem_test.cpp", "src/crypto_asy_key_generator_cov_test.cpp", "src/crypto_brainpool_asy_key_generator_test.cpp", "src/crypto_brainpool_key_agreement_test.cpp", diff --git a/test/unittest/src/crypto_asy_key_convert_pem_test.cpp b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp new file mode 100644 index 0000000..86c7ef8 --- /dev/null +++ b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp @@ -0,0 +1,1084 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "securec.h" + +#include "asy_key_generator.h" +#include "asy_key_generator_spi.h" +#include "blob.h" +#include "memory.h" +#include "params_parser.h" +#include "alg_25519_asy_key_generator_openssl.h" +#include "dh_asy_key_generator_openssl.h" +#include "dsa_asy_key_generator_openssl.h" +#include "ecc_asy_key_generator_openssl.h" +#include "sm2_asy_key_generator_openssl.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoAsyKeyConvertPemTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void CryptoAsyKeyConvertPemTest::SetUpTestCase() {} +void CryptoAsyKeyConvertPemTest::TearDownTestCase() {} +void CryptoAsyKeyConvertPemTest::SetUp() {} +void CryptoAsyKeyConvertPemTest::TearDown() {} + +static string g_testSm2PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGIAgEAMBQGCCqBHM9VAYItBggqgRzPVQGCLQRtMGsCAQEEIA200l6+4y/sASFH\n" + "W+v2ivubPvilyNPD5+iBSnyIb+pHoUQDQgAEylRVudZ35l9vBwX8Zeqq7m9cGTqo\n" + "Mc7m8Lmj107pifm2Qd7kKyYiBa1568t4yEPp5KLfPs1TGgiGoLIsvJeARA==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testSm2PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEEDZi8UI/QxT70W8M3q3C7h+W+Zl6\n" + "8rP7SLCnZXYQPNKDqZEOPi/Vq0CRS9IS438yq4ZadxpDXothWk/bPYtOog==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testX25519PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MC4CAQAwBQYDK2VuBCIEIDBcZrfXH+c4pAmTEFu9yoyCEIZSiGkfIZgFy2Ov58dh\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testX25519PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MCowBQYDK2VuAyEA2L8/1ZjPmQi2x46Rg3+H/BLwJvmbKocfaMeWr4IuMWg=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEd25519PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MC4CAQAwBQYDK2VwBCIEIGeiM+8OWg71i9eF6Z8PszWstvLW11eJJKKo9RyHyXkV\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEd25519PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MCowBQYDK2VwAyEAPfx7zgwln/YVAT0oFLCp87qNS43QBSHJ0ttb0GImUNI=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccSecp224r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MHgCAQAwEAYHKoZIzj0CAQYFK4EEACEEYTBfAgEBBByoNkUhCLcFLDPh3yAnFvx9\n" + "QRnVZJHMhTQnO1SXoTwDOgAEvc6xX46WjjwfIz+/VBVH49OCEVRrGaVGi65dTabd\n" + "UUTvtreiwA2lW2hS2EI3LaE3VvBROnOIYqU=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccSecp224r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "ME4wEAYHKoZIzj0CAQYFK4EEACEDOgAEvc6xX46WjjwfIz+/VBVH49OCEVRrGaVG\n" + "i65dTabdUUTvtreiwA2lW2hS2EI3LaE3VvBROnOIYqU=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDsa1024Prikey = "-----BEGIN PRIVATE KEY-----\n" + "MIIBWgIBADCCATMGByqGSM44BAEwggEmAoGBAP2TzPnHnQkBvcT5LE3upXUv21Pg\n" + "bLgrPycAMjr88vVCixnL/EnAO5HIbqmLHoum9wShT9Lb4UnBDeOB3gF/JE9xyAJ0\n" + "ULNfWMykUr3/YudEHBi5C63gvhA80sLkB3udQxXoWdhrMDTC+JxAmOaoLJlXLOXm\n" + "KpP9RpdGIBLfXXu1Ah0AqNktdrld7vGDCD9/JXYmfDtipMde3LDwc0luhQKBgB0+\n" + "Sa/8d4t4KTJaBe7x3gb0SD2B9K/GoZbgS0a5nRpvwai4pqmEcU9dtwW6fwUFg4Eq\n" + "9Kj7cJZc2k6b8b0Dwt0c/iUE+VE7cVCCsO6nh5i+r0P2Upkx+DBR8ZuRrpxQqNjl\n" + "ES81GmQTKGtUqy3+EKXR08wcf3njBsE1hDq5nECeBB4CHHFSEVmDW3oGTmo4xStB\n" + "hdZIq5iPeBfIGIHFt0M=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDsa1024Pubkey = "-----BEGIN PUBLIC KEY-----\n" + "MIIBvzCCATMGByqGSM44BAEwggEmAoGBAP2TzPnHnQkBvcT5LE3upXUv21PgbLgr\n" + "PycAMjr88vVCixnL/EnAO5HIbqmLHoum9wShT9Lb4UnBDeOB3gF/JE9xyAJ0ULNf\n" + "WMykUr3/YudEHBi5C63gvhA80sLkB3udQxXoWdhrMDTC+JxAmOaoLJlXLOXmKpP9\n" + "RpdGIBLfXXu1Ah0AqNktdrld7vGDCD9/JXYmfDtipMde3LDwc0luhQKBgB0+Sa/8\n" + "d4t4KTJaBe7x3gb0SD2B9K/GoZbgS0a5nRpvwai4pqmEcU9dtwW6fwUFg4Eq9Kj7\n" + "cJZc2k6b8b0Dwt0c/iUE+VE7cVCCsO6nh5i+r0P2Upkx+DBR8ZuRrpxQqNjlES81\n" + "GmQTKGtUqy3+EKXR08wcf3njBsE1hDq5nECeA4GFAAKBgQDDkKC11pEMGnF93lsH\n" + "61vLd7y2xvt6mKRw/AExsYgQBdOMJ+w2sSapEbRI/XUCX7Z4E0nN89xBl/PzbywO\n" + "0yfRqdLTwk5RSurQW7WglYPtMzR24dPCxa9woqyo5OTSCTx0FH2BQVsNdEloYQKo\n" + "6c4+rzj2DLaALOBrKEg9wTAmng==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp1536PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIH4AgEAMIHVBgkqhkiG9w0BAwEwgccCgcEA///////////JD9qiIWjCNMTGYouA\n" + "3BzRKQJOCIpnzHQCC76mOxObIlFKCHmONATd75UZs806QxswKwpt8l8UN0/hNW1t\n" + "UcJF5IW1dmJefsb0TELppjftawv/XLb0Brft7jhr+1qJn6WunyQRfEsf5kkoZlHs\n" + "5Fs9wgB8uKFjvwWY2kg2HFXTmmkWP6j9JM9fg2VdI9yjrZYcYvNWIIVSu57VKQdw\n" + "lpZtZww1Tkq8mATxdGwIyiNzJ///////////AgECBBsCGXIeKZHN2Qp5+JSnHAam\n" + "RiDePOsqbd2mae8=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp1536PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIBoDCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKLgNwc\n" + "0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVtbVHC\n" + "ReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR7ORb\n" + "PcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkHcJaW\n" + "bWcMNU5KvJgE8XRsCMojcyf//////////wIBAgOBxQACgcEAuj+cH1r8RNxBPAl7\n" + "CG76b50cbn1Rb04be/ONImxdhO9zEx/eUtnT1/3PR7j+7UNfvf6J7leQ5YorUz6F\n" + "5anKVUURi1XljLK6GcWBtqyCP0MMuO8FX5Dk8JBlCjTzuP5ClA0gofVAfcp3FYcq\n" + "VrSUDFn1SZt2MdkWe6zR4SDkFrlGTYa2EY5WKD5AR4piXi3m0PvPp+10oe3x6BOZ\n" + "RBvXAtLiP0nTUnhDX2N8FdyiU9Xn9QxajBRI1Jn85v/Qwa0o\n" + "-----END PUBLIC KEY-----\n"; + + +static string g_testDhFfdhe2048PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIBPgIBADCCARcGCSqGSIb3DQEDATCCAQgCggEBAP//////////rfhUWKK7Spqv\n" + "3FYgJz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT\n" + "3x7V1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId\n" + "8VihNq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSu\n" + "Vu3nY3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD\n" + "/jsbTG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhKFyX//////////8C\n" + "AQIEHgIcC6C96/TJHrL6iOaoXiBKyamHP861V3XxMs3Fsw==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhFfdhe2048PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIICJTCCARcGCSqGSIb3DQEDATCCAQgCggEBAP//////////rfhUWKK7Spqv3FYg\n" + "Jz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT3x7V\n" + "1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId8Vih\n" + "Nq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSuVu3n\n" + "Y3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD/jsb\n" + "TG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhKFyX//////////8CAQID\n" + "ggEGAAKCAQEA99dycUYKbYBfecmzMQ+QnGDQ7IfF41i8GbEE6m6Lb27br7XFHxUB\n" + "xS85SOYQGUhup5FCyftzRdx2/zYHatdg51Mn+YxgB1OEa/gTxpRY1UC49bs+p/w6\n" + "Q8+ZRslDXnTRCGSeiw4TCzC0ynMN1i0TcTnOh33Vd8exKIg73jedgLi6//+wZjtH\n" + "ufYua4jKKux/Qas/ILi0K1pQOZ0J4z0FuKVlLvprth8vwRF8kpLVg5q25JQ9K7do\n" + "/BZEwcfXvd61/FoWQv75DEydiFHC/iMppwwa8QhYj5jC5C9yZLXlvoOiOB5UPkti\n" + "59nqvRQJevtDMFX/fB9KLWVkgAIUqVLEVw==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhFfdhe3072PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIBxQIBADCCAZcGCSqGSIb3DQEDATCCAYgCggGBAP//////////rfhUWKK7Spqv\n" + "3FYgJz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT\n" + "3x7V1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId\n" + "8VihNq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSu\n" + "Vu3nY3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD\n" + "/jsbTG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8\n" + "NPTe+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0\n" + "/URS4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4K\n" + "vNBr+lPd7zwbIO4/1Z18JeQdK2bGLjf//////////wIBAgQlAiMDFnJti6Y7aWEb\n" + "9//FRAcAqlpDn1l6EbzY8cpVYPS4VhG4aw==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhFfdhe3072PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIDJDCCAZcGCSqGSIb3DQEDATCCAYgCggGBAP//////////rfhUWKK7Spqv3FYg\n" + "Jz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT3x7V\n" + "1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId8Vih\n" + "Nq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSuVu3n\n" + "Y3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD/jsb\n" + "TG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8NPTe\n" + "+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0/URS\n" + "4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4KvNBr\n" + "+lPd7zwbIO4/1Z18JeQdK2bGLjf//////////wIBAgOCAYUAAoIBgCnL/c2/ajEL\n" + "hD+XQUVOA96sz/Z/tB5Oimrj7EFi/F0mv4NQX3Xj+AeS1vfvEVMDuTDFWiVLIyIX\n" + "8k+1efJf8MxZvd6ZyqyCua0LQIc1kSAr/QGqOL0sUZMlKpoyuZ8eGN0mM7JlJFag\n" + "8yvXtreycFaoZhaHUlqfj5ICEmgALhX3FjR5H3Lm1AAdiDzAwEi9VmhdTKnt0qia\n" + "3J20vI8n0SgtYTHssYHDJwW6n4LomLim1Jp/AqOhkXUFTyaYLW32bSXM466D06pt\n" + "LNedT2tYNVV2oOS7mwGDJOPoJ2ON6Rh82eGuPtmeLvA+5oVaB1+isDAxNLXxCohT\n" + "LiDZ1tDKe+/syblIMR6LCTQmb4EpgZHQsfO7BSsTHwI9/55POrTZ944rMuV7Ro3y\n" + "aGvxMBLmuoBMKK+jkOF3NuzGxosJaKiAH2skbccdzYs1Qt401dCh0IXqCVjFIwHp\n" + "cywQXQv6YZ0B45T9b7m6H1LjUbAfOdxjLYGe6JtJ8phBw9KTsBpCgA==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhFfdhe4096PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIICSwIBADCCAhcGCSqGSIb3DQEDATCCAggCggIBAP//////////rfhUWKK7Spqv\n" + "3FYgJz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT\n" + "3x7V1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId\n" + "8VihNq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSu\n" + "Vu3nY3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD\n" + "/jsbTG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8\n" + "NPTe+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0\n" + "/URS4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4K\n" + "vNBr+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3\n" + "Y88dVQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJ\n" + "KZmjM8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHG\n" + "igB+XmVfav//////////AgECBCsCKRfw3Z6+8+P0Hn/8ftdOa3wcFp/IU7vBV5Y3\n" + "dj1X9NSoW567eG6/s2Qs\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhFfdhe4096PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIEJTCCAhcGCSqGSIb3DQEDATCCAggCggIBAP//////////rfhUWKK7Spqv3FYg\n" + "Jz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT3x7V\n" + "1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId8Vih\n" + "Nq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSuVu3n\n" + "Y3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD/jsb\n" + "TG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8NPTe\n" + "+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0/URS\n" + "4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4KvNBr\n" + "+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3Y88d\n" + "VQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJKZmj\n" + "M8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHGigB+\n" + "XmVfav//////////AgECA4ICBgACggIBAKigucWOH8I8vq12hTuGkZiJhdfksOMo\n" + "i/9xtSf+9Ba6eLnSJUBWVO/rbEBi+iJGYwff1r8u8l7AtD2Hcw/wSPZAlt0LXXVX\n" + "TLGk4UxQNxpMaCdsHdxCNxnPQ7HSbkig4ot96+8N2vwXgLUWcd2DIagrh1iN7OAI\n" + "D1j/mCFDwi7gP3az5TgViowTvLi6o5JcN4oew6MMVOiv626lGzk4okaOAyjUlW10\n" + "ZbV8j0Bk7PukOUzXCwDC6V2TxLkDUNkXwg4pDHVGYmQCO9MpECA9zrW+facYwMkg\n" + "k8GJoQ1r7xtD+2fYpFyYhlQPZ5dO1GuCdVa1WbS2/8PRw8jZu5ckQS35OCoBB7JC\n" + "bz1dmWRueDpi2ktpDgjxyOIN7uZQyIFIpsfapt/o0ZszkVWxJvYrR0SdU+dXMjRp\n" + "QlPotOEVq39Hqp7hDa4YDM/Ioi8JIMhAnrynEPlPgzwU2PVelPfJ5adox5+hjG0u\n" + "xdmMGTCI+EMUa7WluPms8movWCvFOT+AUaPS8vkRB5hHcslcWIN+8eUWQRWXuPJ0\n" + "wDDaOWfONV+/irUnlBldB7QL8lqv+hmzqMKkT6Qq3RVcewlIBFTQ5R+T2MjB287V\n" + "sz5ANidkSXiZAqBrOGP4izqZWyY7e0KckPFw9pPJOcImAde33iRsCS+SX2x+ik1Q\n" + "AbVOf7Vd2viT\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhFfdhe6144PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIDUQIBADCCAxcGCSqGSIb3DQEDATCCAwgCggMBAP//////////rfhUWKK7Spqv\n" + "3FYgJz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT\n" + "3x7V1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId\n" + "8VihNq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSu\n" + "Vu3nY3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD\n" + "/jsbTG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8\n" + "NPTe+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0\n" + "/URS4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4K\n" + "vNBr+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3\n" + "Y88dVQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJ\n" + "KZmjM8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHG\n" + "igB+Xg3ZAgv9ZLZFA2x6Tmd9LDhTKjojukRCyvU+pju0VDKbdiTIkXvdZLHA/Uyz\n" + "jowzTHAcOs2tBlf8z+xxmx9cPk5GBB84gUf7TP20d6UkcfepqWkQuFUyLttjQNig\n" + "DvCSNQUR4wq+wf/546Juf7KfjBgwI8NYfjjaAHfZtHY+TkuUsrvBlMZlHnfK+ZLu\n" + "qsAjKigb9rOnOcEiYRaCCujbWEemfL75yQkbRi1TjNcrA3Rq539eYiksMRViqEZQ\n" + "XcgtuFQziuSfUjXJW5EXjM8t1crO9APsnRgQxicrBFs7cfnca4DWP91KjprbHmli\n" + "ppUm1DFhwaQdVw15ONrUpA4ynNDkDmX//////////wIBAgQxAi9TPRFZd41FTBHp\n" + "XLtToxZ2gzSWglVgDRJXLTl9cbrJpO3q+hGp5aHn0ICfgt73Xg==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhFfdhe6144PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIGJTCCAxcGCSqGSIb3DQEDATCCAwgCggMBAP//////////rfhUWKK7Spqv3FYg\n" + "Jz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT3x7V\n" + "1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId8Vih\n" + "Nq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSuVu3n\n" + "Y3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD/jsb\n" + "TG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8NPTe\n" + "+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0/URS\n" + "4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4KvNBr\n" + "+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3Y88d\n" + "VQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJKZmj\n" + "M8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHGigB+\n" + "Xg3ZAgv9ZLZFA2x6Tmd9LDhTKjojukRCyvU+pju0VDKbdiTIkXvdZLHA/Uyzjowz\n" + "THAcOs2tBlf8z+xxmx9cPk5GBB84gUf7TP20d6UkcfepqWkQuFUyLttjQNigDvCS\n" + "NQUR4wq+wf/546Juf7KfjBgwI8NYfjjaAHfZtHY+TkuUsrvBlMZlHnfK+ZLuqsAj\n" + "Kigb9rOnOcEiYRaCCujbWEemfL75yQkbRi1TjNcrA3Rq539eYiksMRViqEZQXcgt\n" + "uFQziuSfUjXJW5EXjM8t1crO9APsnRgQxicrBFs7cfnca4DWP91KjprbHmlippUm\n" + "1DFhwaQdVw15ONrUpA4ynNDkDmX//////////wIBAgOCAwYAAoIDAQCHLU8SlkQw\n" + "3QT/NXoXC+9p8zv5D9E4m5bdiWYqkRnnjM/TpHm3tvsWEIXjOBm7L24ekIvU6bwd\n" + "BTh7oKs0bVdXMlT00BV0CZu7VxSernhE0zMccGTGEOyOjJE14YOVu/+gSDrc16QH\n" + "fgNSbKUEd96Xmwdm46ZuGHyWwegnTAZrsJtTufX5xbrOFFHcCJFA5I5vEs6yXl7s\n" + "dH/QmjzWkmtSt26QV9tazxtjeTnpDkhCzOlk0EFksdPaE5Ddwkrqqo6723qAcNzh\n" + "FmJ7/GEL2w/pwLAk+WhCiHilLYti5f4ZixAyIRewQMbiLG4qZhD18L9a9+5WVl+t\n" + "lfFFncZQ8k+Ma3mzNMfgVceBHvAeqzqGyXAzG0aNvmYLT9DQ7MMB1x5IGz/EbvFl\n" + "aJdmv1s7RDBIgxvaE3HwcyUxvahtc/8b4jG1XWz9mSjTv3jUs8d/OWN4daRvlPvU\n" + "Nkz4eoUkqjE6tYmLDBAXfPLeUPPN3J4MIHEA9OdA8y+9VjBoVUGXscInOY74bF5V\n" + "Ry08ecLaJbC5puuD7y9FVzcy+b9tUyhbdKB+xI17uW4R3wbsBEBqRdgNeeGtnDHb\n" + "pSNSBwCsxYdR+08a29PoXw25ABzZesl8jqggMepgFUHIBT6aIGAtU/+Ht+H7++Az\n" + "7R746IqQ9ZPfW5dOB0ZHV7QlWc8rp8mPq39KJtuvkqR7oVXLG4etedeKPOo6G0Fn\n" + "hsqU8YVwnEzCxTiOQ974RQeL4QXC6vvx8g5wJXHqO5jJ7kGpIGvPzlEm0BENn2sk\n" + "fJKPwNV/sKxHQzHp9ngjuIwLtP4AlHBgILJWLhfW+yIC7l3szYZWVnZ3Og1URsYg\n" + "uvq1mapA+Npz5tWTsDrNg9+Dl9NX90pILn91g33b2fuPFL4faOIcicaYIGm3TWLS\n" + "gN1JbUD1LLjV8oxTJ/MRRRzktBs3NElGAks0NKkIMzoCF2X++r7Qow+rbkHtT6bN\n" + "oGE+prxc+oLDee7WBVc0wPPG5sRdXzWVHlySi40OYjMoWhFq5rA+s4s=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhFfdhe8192PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIEVAIBADCCBBcGCSqGSIb3DQEDATCCBAgCggQBAP//////////rfhUWKK7Spqv\n" + "3FYgJz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT\n" + "3x7V1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId\n" + "8VihNq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSu\n" + "Vu3nY3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD\n" + "/jsbTG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8\n" + "NPTe+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0\n" + "/URS4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4K\n" + "vNBr+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3\n" + "Y88dVQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJ\n" + "KZmjM8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHG\n" + "igB+Xg3ZAgv9ZLZFA2x6Tmd9LDhTKjojukRCyvU+pju0VDKbdiTIkXvdZLHA/Uyz\n" + "jowzTHAcOs2tBlf8z+xxmx9cPk5GBB84gUf7TP20d6UkcfepqWkQuFUyLttjQNig\n" + "DvCSNQUR4wq+wf/546Juf7KfjBgwI8NYfjjaAHfZtHY+TkuUsrvBlMZlHnfK+ZLu\n" + "qsAjKigb9rOnOcEiYRaCCujbWEemfL75yQkbRi1TjNcrA3Rq539eYiksMRViqEZQ\n" + "XcgtuFQziuSfUjXJW5EXjM8t1crO9APsnRgQxicrBFs7cfnca4DWP91KjprbHmli\n" + "ppUm1DFhwaQdVw15ONrUpA4ynM/0aqo2rQBM9gDIOB5CWjHZUa5k/bI/zslQnUNo\n" + "f+tp7dHMXguMw732SxDvhrYxQqOriClVWy90fJMmZcssDxzAG9cCKTiIOdKvBeRU\n" + "UErHi3WCgihGwLo1w19cWRYMwEb9glFUH8aMnIawIrtwmYdqRg50UaipMQlwP+4c\n" + "IX5sOCblLFGqaR4OQjz8menjFlDBIXtiSBbNrZqV+dW4AZSI2cCgof4wdaV34jGD\n" + "+B1KPy+kVx78jOC6ik/otoVd/nKwpm7e0vur++WKMPr6vhxdcah+L3Qe+MH+hv6m\n" + "u/3lMGd/DZfRHUn3qEQ9CCLlBqn0YU4BHiqUg4/4jNaMi7fFxkJM//////////8C\n" + "AQIENAIyNvBPpNeXtnI5saYMiXvrUSRJw7Yq6QWkYU2C9Bf6vGpP3dEsmHQVbWPe\n" + "IEHpmLKk1g8=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhFfdhe8192PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIIJTCCBBcGCSqGSIb3DQEDATCCBAgCggQBAP//////////rfhUWKK7Spqv3FYg\n" + "Jz088di5xYPOLTaVqeE2QRRkM/vMk53OJJs++X0v42NjDHXY9oGyAq7EYXrT3x7V\n" + "1f1lYSQz9R9fBm7QhWNlVT3tGvO1VxNef1fJNZhPDHDg5ot34qaJ2vPv6HId8Vih\n" + "Nq3nNTCsyk9IOnl6vAqxgrMk+2HRCKlLssjj+7lq2rdg1/RoHU9Co945TfSuVu3n\n" + "Y3K7GQsHp8juCm1wngL84c334uzANATNKDQvYZFy/pzphYP/jk8SMu7ygYPD/jsb\n" + "TG+tczu1/LwuwiAFxY7xg30Wg7LG80omwbLv+ohrQjhhH8/c3jVbO2UZA1u8NPTe\n" + "+ZwCOGG0b8nW5skHetkdJpH39+5ZjLD6wYbZHK7+EwmFE5JwtBMMk7xDeUT0/URS\n" + "4tdN02Ty4h5x9Uv/XK6Cq5yd9p7obSvFIjY6DavFIZebDeraHb+aQtXESE4KvNBr\n" + "+lPd7zwbIO4/1Z18JeQdK2aeHvFub1LDFk30+3kw6eTliFe2rH1fQtafbRh3Y88d\n" + "VQNABIf1W6V+Mcx6cTXIhu+0MYrtah4BLZ5oMqkHYAqRgTDEbcd4+XGtADgJKZmj\n" + "M8uLehoduT1xQAA8Kk7OqfmNCswKgpHNzsl9z47JtVp/iKRrTbWoUfRBguHGigB+\n" + "Xg3ZAgv9ZLZFA2x6Tmd9LDhTKjojukRCyvU+pju0VDKbdiTIkXvdZLHA/Uyzjowz\n" + "THAcOs2tBlf8z+xxmx9cPk5GBB84gUf7TP20d6UkcfepqWkQuFUyLttjQNigDvCS\n" + "NQUR4wq+wf/546Juf7KfjBgwI8NYfjjaAHfZtHY+TkuUsrvBlMZlHnfK+ZLuqsAj\n" + "Kigb9rOnOcEiYRaCCujbWEemfL75yQkbRi1TjNcrA3Rq539eYiksMRViqEZQXcgt\n" + "uFQziuSfUjXJW5EXjM8t1crO9APsnRgQxicrBFs7cfnca4DWP91KjprbHmlippUm\n" + "1DFhwaQdVw15ONrUpA4ynM/0aqo2rQBM9gDIOB5CWjHZUa5k/bI/zslQnUNof+tp\n" + "7dHMXguMw732SxDvhrYxQqOriClVWy90fJMmZcssDxzAG9cCKTiIOdKvBeRUUErH\n" + "i3WCgihGwLo1w19cWRYMwEb9glFUH8aMnIawIrtwmYdqRg50UaipMQlwP+4cIX5s\n" + "OCblLFGqaR4OQjz8menjFlDBIXtiSBbNrZqV+dW4AZSI2cCgof4wdaV34jGD+B1K\n" + "Py+kVx78jOC6ik/otoVd/nKwpm7e0vur++WKMPr6vhxdcah+L3Qe+MH+hv6mu/3l\n" + "MGd/DZfRHUn3qEQ9CCLlBqn0YU4BHiqUg4/4jNaMi7fFxkJM//////////8CAQID\n" + "ggQGAAKCBAEAsDdW0aV/QrWols/oaofco+HGc9BEdt+WwxibMrtn3IBv7XG7qnzL\n" + "h5x63WKlt5Gn+13KcNlap7YN1GM8AJpt7V4w3vuuevjU6yPDsVe7r658zadlkEoS\n" + "6bhsBcUOnq7NYxJdC70dOY77moDhuwLbv1InwRTUL71sv7tTONZ54SDonW9W8uSj\n" + "EIT7Pru3hDl1GNQKyGIKTTVZbaxFTL7OVNCL12Y20ijhEzWh5LhkhocWLL5ef+g+\n" + "WdH52ta1nwaT2nJjposAxfngsNy7u1SeZjovHhQp5Ef7yV87MW2kcX8u5KNN1wES\n" + "22JE5/95wr4O3OlmTmlUYDABm0A5TsCWENonuejSMtRwCufUZ3UmCrBDkXXD4kRb\n" + "JhykGp1smKboHwzk2VlZWpSLK02F0QaIEoyWGKyxinX63lG0GsLEaK7lIUo9Irve\n" + "ugdPbjxbERdCmnq7JprzZnyLWvdXUErh2l6NyNw8ZMfO3Cl8F3DCeWS8eaBh1fiN\n" + "6TAu+fyhgAVvGjW79BJCq1Sym+OlP71AXckzSHWVeqbBvwXLM54bQmcEJXakQQQk\n" + "ZMwyuvHRtmBsxHVxqb8Y8K6oVzr7i3EmyYCZNXv4JNAgIFbXKe6PkuNVnblxCNea\n" + "qMCviXtKpoIFpFcukwi8WjotLN7oXNW80/tv9kOOG5DI3ziPeJheHQLbzJuUA8Ew\n" + "57sqCjAXhIIrQ5W0QDULGbQnHY5IAeyi4YIiSGQg3ECAbHkdmYG8a9WyabM/Sh6H\n" + "+i2bU0S0W8w2zt6woAiBu1/AqCXDCJIy2aU6n3h3R/BLWJvOFcTUBy/NmKvB1LHq\n" + "ynTydOK+Qy0wzKr0ubB5rhWqk9Zv7ROC22LQJfXdH9bdjQQcOFSDOMIvKmD5HBaD\n" + "XzcNvn0LSYexTSPbY7U/1JwpXp54BYvSVf1JdxGO3UM85ODKSg8dlmpV3R29+6VA\n" + "xiJwVqaQY18AfWFxEOcTasxB5cv8DtCEYbq2L4fSg4Ix/ja3u4yU7HnWi76CajwT\n" + "gzKs9EB7ZshsUCp6IMRBThY8x7fKOtcpxL6JiL+SjB/eQfzQDhVo0rohiZ1m3g3p\n" + "+n1Sru1JdnWIl+iozCU5Iwy2HG4IfK2noUDBxpn8kFl+ZK4RQTuyzCbbFOeIFNrt\n" + "TrMTJszuiyLwqxZNdONKJoA0HMyxEnpt4wgN30jOyJtf2XY0yaM0s+gfAzyw09HF\n" + "t6wfDQ2Vj0RBBF9fLp/RBGZArt5lN5DIL/JwB0Lwec6cyDf6PlG7Cc2BOaejKgof\n" + "ffoNDeTER8jTZb63tfTkyiOxDjwggHZdx8RzG7wde04TLegw3VGdVAX6Q5WrnLeS\n" + "TPUgTvYxns26sKVlFjRKqVKVCmy68iMB5Q==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp2048PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIBPwIBADCCARcGCSqGSIb3DQEDATCCAQgCggEBAP//////////yQ/aoiFowjTE\n" + "xmKLgNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP\n" + "4TVtbVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJ\n" + "KGZR7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue\n" + "1SkHcJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1\n" + "xV3wb0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKrKpo//////////8C\n" + "AQIEHwIdAPRToxgVjHMVN8nkoSWKprLl8llag1wAYmiLrng=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp2048PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIICJTCCARcGCSqGSIb3DQEDATCCAQgCggEBAP//////////yQ/aoiFowjTExmKL\n" + "gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n" + "bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n" + "7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkH\n" + "cJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1xV3w\n" + "b0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKrKpo//////////8CAQID\n" + "ggEGAAKCAQEAggsOz2iHuIXDEXGeei4/4c2E1I2gVJ/MuELlf1l2vZdnQZzldZYs\n" + "HMDz77rfHHzXOisSpgEr7eY5lcRogtf5+cT7pBljnou/e+yKUlfdo0rrC/+koAp8\n" + "N+hAYTkH2Fwt/oEWckcEuuYJLnU5L0j7AcWSGjZrI0driQaQM40hzgfHl7j1fRcU\n" + "t9Tl2ycdzrV0F/C7SIa/P1qstdxTzjAZlmoWVC2W3eC5wM3b/A/tsH73C84vKpcn\n" + "JCvcfg7HpvXmwTbywGfoXtlDgcM3GaZVFvAdqHcEdQyvWp9ePqQ23oSxC//7TgXi\n" + "CUiaF/zepTKo3Z2aBTio3ghUCg6hfcRWdw==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp3072PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIBxQIBADCCAZcGCSqGSIb3DQEDATCCAYgCggGBAP//////////yQ/aoiFowjTE\n" + "xmKLgNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP\n" + "4TVtbVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJ\n" + "KGZR7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue\n" + "1SkHcJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1\n" + "xV3wb0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOo\n" + "VSGr3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O\n" + "49ImGtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII\n" + "4k+gdOWrMUPbW/zg/RCOS4LRIKk60sr//////////wIBAgQlAiMENiPbUKDmUyxx\n" + "OFZZ2Fsb0Z4ONl0+xPwLUxWG9gmXoRLL6A==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp3072PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIDJTCCAZcGCSqGSIb3DQEDATCCAYgCggGBAP//////////yQ/aoiFowjTExmKL\n" + "gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n" + "bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n" + "7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkH\n" + "cJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1xV3w\n" + "b0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOoVSGr\n" + "3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O49Im\n" + "GtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII4k+g\n" + "dOWrMUPbW/zg/RCOS4LRIKk60sr//////////wIBAgOCAYYAAoIBgQDeqifvv/RC\n" + "T+VpuDB9QD0WHxjTgXAlhH3jwQn7rdqz7VgLOKezuiWKXRbPiAmvq7YvweHQF3m5\n" + "mVSgcmTY7Jdea/tZS3G3/fjxzxaRuVH73E0BmbNCIeiL/KQcRLqqHJ4s486ezeoP\n" + "MgMIuYZ/Q95otbsAbufiiI2TvFXy9M7//m097+nL3eAnMV3bomJ1vgLacO6nm3xT\n" + "a+MfYCZFzzreTkUWrnzcvvPLdXI3cOVimqiuWhMuxd3LTAm7cnTNyCCpQQ+VwwZT\n" + "CX1b5MBiNuEHGKqBAF65L2o1yi5kPgjq4ojiJNEjx4owoSDdZP5GG+IJPO/ccLQo\n" + "KCnRW+zAJykpaZp7Ujpc2eNJ+IoR+uXUvhuott7CpgRAZlhTCkv7ORvYuTX8AwUo\n" + "JJ1weksOcRxoWpLSoi4g4t90HnOeXXx0x3dqzjGlXId2VflcWNApNsHgC1Z6G+Qs\n" + "QJTpEM684ClYVc+T8wexkX3EdfYmBiIRaUlJ7DTxQzJKhTtuP7kg4mk=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp4096PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIICSwIBADCCAhcGCSqGSIb3DQEDATCCAggCggIBAP//////////yQ/aoiFowjTE\n" + "xmKLgNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP\n" + "4TVtbVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJ\n" + "KGZR7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue\n" + "1SkHcJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1\n" + "xV3wb0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOo\n" + "VSGr3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O\n" + "49ImGtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII\n" + "4k+gdOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwa\n" + "lGg0thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6Ij\n" + "O6GGUVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N\n" + "9DXJNAYxmf//////////AgECBCsCKRNHTBYLOilaRpAM+smrwpKazwY6qmI60sZa\n" + "trdrzm3cdKsTGMV+G4Xj\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp4096PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIEJTCCAhcGCSqGSIb3DQEDATCCAggCggIBAP//////////yQ/aoiFowjTExmKL\n" + "gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n" + "bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n" + "7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkH\n" + "cJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1xV3w\n" + "b0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOoVSGr\n" + "3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O49Im\n" + "GtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII4k+g\n" + "dOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwalGg0\n" + "thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6IjO6GG\n" + "UVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N9DXJ\n" + "NAYxmf//////////AgECA4ICBgACggIBANVYMZwPOuZPzRGg5ved0+Tqqkca2zqI\n" + "fJT91Bi/4ks8Ppxf1D7PvmNXUtxPjjrxNleDATsZOjKsjSunUB7szzGizuH6CaO9\n" + "HFogxp/ugvSRF6GkISbcTN8Ek89iqImZkC67e48L1sgtixrd5BKMF1i5MJs7vdOj\n" + "gH0vFCoGxPR878HnmN8E0+gS2z6JVXvgIYQApMqXuptICrGUGQrTILUDf/lDLh3l\n" + "VMQO908GJcmGWImSheWUyNqz88eZrff4lFTRUz4jx0dKowN3SrTGNkWMcNsK7bIg\n" + "Qe0408Ax68olQBgbKCAllfHUBGIP0XIDvvXiuqMaFni7NKsecYKCNPy2iDyzCNen\n" + "kdvFc/buG5VUWSNjEQNfO/7K2OBZTUoofYS1/v8AXmPI1KBJB6Cd3yObVghv74lT\n" + "Itri59BffG8HkpfI4zGVuk1nZ8sBJqqCY1ZR4Xcpj/PbcA5PioeUTKrkffsm/Xby\n" + "1u7LEiOZFag3nJ0DArGwCtxoODdFFaF6rq5IcCcNcrP/lW9E+oY+Rus0eRN0h0w8\n" + "MhWqJQ6y6fdPgcTvimWtUfE2o/9vXvvONJDk4bUUpRw/D24Mg4x9/0Zjp5zWaia/\n" + "sLNTm2RLMGU0PjBGIc/33+6JFbO3t4FdsDU+mTiaissfgAnzBLEnsMjw3Du/HC9s\n" + "L+99jo6k4lcq\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp6144PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIDUQIBADCCAxcGCSqGSIb3DQEDATCCAwgCggMBAP//////////yQ/aoiFowjTE\n" + "xmKLgNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP\n" + "4TVtbVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJ\n" + "KGZR7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue\n" + "1SkHcJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1\n" + "xV3wb0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOo\n" + "VSGr3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O\n" + "49ImGtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII\n" + "4k+gdOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwa\n" + "lGg0thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6Ij\n" + "O6GGUVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N\n" + "9DXJNAKEkjbD+rTSfHAmwdTcsmAmRt7JdR52Pbo3vfj/lAatnlMO5ds4L0EwAa6w\n" + "alPtkCfYMReXJ7CGWokY2j7b68+bFO1Ezmy6ztS7G9t/FEfmzCVLMyBRUSvXr0Jv\n" + "uPQBN4zSv1mDygHGS5Ls8DLqFdFyHQP0gtfObnT+9tVecC9GmAyCtahAMZALHJ5Z\n" + "58l/vsfo8yOpen42zIi+Dx1Ft/9YWsVL1AeyK0FUqsyPbX6/SOHYFMxe0g+AN+Cn\n" + "lxXu8pvjKAah1Yu3xdp29VCqPYofv/DrGcyxoxPVXNpWyewu8pYyOH/o1248BGgE\n" + "Po9mP0hg7hK/LVsLdHTW5pT5Hm3MQCT//////////wIBAgQxAi9/Au8+qm3n56dp\n" + "3l5vq0PO5DQUxznbuMdnJu/hkHz7hSh5+MNgKQECtgnxjatsWg==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp6144PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIGJDCCAxcGCSqGSIb3DQEDATCCAwgCggMBAP//////////yQ/aoiFowjTExmKL\n" + "gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n" + "bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n" + "7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkH\n" + "cJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1xV3w\n" + "b0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOoVSGr\n" + "3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O49Im\n" + "GtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII4k+g\n" + "dOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwalGg0\n" + "thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6IjO6GG\n" + "UVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N9DXJ\n" + "NAKEkjbD+rTSfHAmwdTcsmAmRt7JdR52Pbo3vfj/lAatnlMO5ds4L0EwAa6walPt\n" + "kCfYMReXJ7CGWokY2j7b68+bFO1Ezmy6ztS7G9t/FEfmzCVLMyBRUSvXr0JvuPQB\n" + "N4zSv1mDygHGS5Ls8DLqFdFyHQP0gtfObnT+9tVecC9GmAyCtahAMZALHJ5Z58l/\n" + "vsfo8yOpen42zIi+Dx1Ft/9YWsVL1AeyK0FUqsyPbX6/SOHYFMxe0g+AN+CnlxXu\n" + "8pvjKAah1Yu3xdp29VCqPYofv/DrGcyxoxPVXNpWyewu8pYyOH/o1248BGgEPo9m\n" + "P0hg7hK/LVsLdHTW5pT5Hm3MQCT//////////wIBAgOCAwUAAoIDAGB/u7i3VHL4\n" + "Mj1OapD7dC5GaQK1joynj/rVLiQihtgOzgEegvwFlXb+0U2s054fngWA9DdVL8WF\n" + "sqhyd+TANDNx52utLRMOyKeovJDpdyCrFU5XOORYC/0W/sKpLhgzD+lPDayj85WK\n" + "xrsutvS/dXQ8sBEe06YOWAEYWoCZ2PMZw7pI8fj0JTfNS0fxHCDO+1uVJeADulM+\n" + "qKDlBHFd0blzRRfUwj/Of3CrtsBajQiH3aG05QkqJyumvMOhEUrkgBGbhnWg9Qi0\n" + "cSZgH5vmRnGCPEvhuX5eRBDwXwTy9UxWxr4c/Y5krnmu0CmZQVNV+cZga71f7MJW\n" + "DUXbgigcF/yZJB/6Ujj70OS7W251UMWpjAMt5pIPuYfFKQ7JyJ/u6AQkgaGcpMLu\n" + "L66ptUJsvGqdACzAq0PieiO8aCuWBqJMKUU3zduVxjPXMjERfUNNeqbefyvmjYb6\n" + "XjF8c/WB0d3d1FTypJ749KTUFXBrhZdOHb+xVYmK4QEdqxZ7XntG/C1GYkGnLaSs\n" + "v7caJ68xs8eP8/0XI7Wd3q1Uxk77dSRBqmq+WsAvnwKY8P3gdbzp/L79j56WZ9Fi\n" + "PghywBjb35CDwa514z4VUfxoeDzjBN6uESYyQf2CeQXIUECZGXepj4s21KXWNhOF\n" + "rVgWu2PhoLIirhdwZEhFTTRAvs+LkOMsVhjkWvlS4+7aRqIiusWUl+SLtbO2Jc0n\n" + "yBS2bVcGkLxniAnUyomou1wbAKr6AFXZQ7W9eT2wiBaHsNyiH7MdWyLw5kpAp5MZ\n" + "wq4hKy1fJu6YDrFMWlP2UDRXyTj8G6aIdsYk1GdUOqnrB+j9q9xxo+prZ10QAIb/\n" + "NpgJmxJa/eJChgMbwlOvfDRHBoqUDnIKOOleHwsj8CHlQiAVd+UoqPORA4jwkH3n\n" + "L86S+1lmy3gYiDz69wauEruz7suOFdViRxA/OIoh0l+F9m7lz8YHo65zljQBdFF0\n" + "PX+9AUeZh/diVQGs7lPp9qiXfdDZ+1l6XskgfNn1N41+RDxBrRHnWA==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDhModp8192PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIIEVQIBADCCBBcGCSqGSIb3DQEDATCCBAgCggQBAP//////////yQ/aoiFowjTE\n" + "xmKLgNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP\n" + "4TVtbVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJ\n" + "KGZR7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue\n" + "1SkHcJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1\n" + "xV3wb0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOo\n" + "VSGr3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O\n" + "49ImGtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII\n" + "4k+gdOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwa\n" + "lGg0thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6Ij\n" + "O6GGUVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N\n" + "9DXJNAKEkjbD+rTSfHAmwdTcsmAmRt7JdR52Pbo3vfj/lAatnlMO5ds4L0EwAa6w\n" + "alPtkCfYMReXJ7CGWokY2j7b68+bFO1Ezmy6ztS7G9t/FEfmzCVLMyBRUSvXr0Jv\n" + "uPQBN4zSv1mDygHGS5Ls8DLqFdFyHQP0gtfObnT+9tVecC9GmAyCtahAMZALHJ5Z\n" + "58l/vsfo8yOpen42zIi+Dx1Ft/9YWsVL1AeyK0FUqsyPbX6/SOHYFMxe0g+AN+Cn\n" + "lxXu8pvjKAah1Yu3xdp29VCqPYofv/DrGcyxoxPVXNpWyewu8pYyOH/o1248BGgE\n" + "Po9mP0hg7hK/LVsLdHTW5pT5Hm2+EVl0o5JvEv7l5Dh3fLapMt+M2L7E0HO5Mbo7\n" + "yDK2jZ3TAHQfp7+K/EftJXb2k2ukJGY6q2OcWuT1aDQjtHQr8cl4I48Wy+OdZS3j\n" + "/bi+/ISK2SIiLgSkA3wHE+tXqBoj8Mc0c/xkbOowa0vLyIYvg4Xd+p1Lf6LAh+h5\n" + "aDMD7VvdOgYrPPWzonimbSoT+D9E+C3fMQ7gdKtqNkWX6JmgJV3BZPMcxQhGhR35\n" + "q0gZXe1+obHVEL1+501z+vNrwx7Pomg1kEb064efkkAJQ4tIHGzXiJoALtXuOCvJ\n" + "GQ2m/AJuR5VY5EdWd+mqnjBQ4nZWlN/IH1bogLlucWDJgN2Y7dPf//////////8C\n" + "AQIENQIzAL5VbOx8Gf9Okpw22McpN5hm04wj+Mok9ZB+eZuuMD9hTBw5SMrz6lP7\n" + "m/WaPrKgRpnw\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDhModp8192PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIIJDCCBBcGCSqGSIb3DQEDATCCBAgCggQBAP//////////yQ/aoiFowjTExmKL\n" + "gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n" + "bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n" + "7ORbPcIAfLihY78FmNpINhxV05ppFj+o/STPX4NlXSPco62WHGLzViCFUrue1SkH\n" + "cJaWbWcMNU5KvJgE8XRsCMoYIXwykF5GLjbOO+OedywYDoYDmyeDouwHoo+1xV3w\n" + "b0xSyd4ry/aVWBcYOZVJfOqVauUV0iYYmPoFEBVyjlqKqsQtrTMXDQRQejOoVSGr\n" + "3xy6ZOz7hQRY2+8KiupxV10GDH2zlw+FpuHkx6v1rozbCTPXHoyU4EolYZ3O49Im\n" + "GtLua/Ev+gbZighk2HYCcz7IamRSHysYF3sgDLvhF1d6YV1sdwmIwLrZRuII4k+g\n" + "dOWrMUPbW/zg/RCOS4LRIKkhCAEacjwSp4fm14hxmhC9ulsmmcMnGGr04jwalGg0\n" + "thUL2iWD6coq1Ezo27vC2wTejvkujvwUH77Kpih8WUdOa8BdmbKWT6CQw6IjO6GG\n" + "UVvn7R9hKXDO4tevuBvddiFwSBzQBpEn1bBaqZO06piNj93Bhv+33JCmwI9N9DXJ\n" + "NAKEkjbD+rTSfHAmwdTcsmAmRt7JdR52Pbo3vfj/lAatnlMO5ds4L0EwAa6walPt\n" + "kCfYMReXJ7CGWokY2j7b68+bFO1Ezmy6ztS7G9t/FEfmzCVLMyBRUSvXr0JvuPQB\n" + "N4zSv1mDygHGS5Ls8DLqFdFyHQP0gtfObnT+9tVecC9GmAyCtahAMZALHJ5Z58l/\n" + "vsfo8yOpen42zIi+Dx1Ft/9YWsVL1AeyK0FUqsyPbX6/SOHYFMxe0g+AN+CnlxXu\n" + "8pvjKAah1Yu3xdp29VCqPYofv/DrGcyxoxPVXNpWyewu8pYyOH/o1248BGgEPo9m\n" + "P0hg7hK/LVsLdHTW5pT5Hm2+EVl0o5JvEv7l5Dh3fLapMt+M2L7E0HO5Mbo7yDK2\n" + "jZ3TAHQfp7+K/EftJXb2k2ukJGY6q2OcWuT1aDQjtHQr8cl4I48Wy+OdZS3j/bi+\n" + "/ISK2SIiLgSkA3wHE+tXqBoj8Mc0c/xkbOowa0vLyIYvg4Xd+p1Lf6LAh+h5aDMD\n" + "7VvdOgYrPPWzonimbSoT+D9E+C3fMQ7gdKtqNkWX6JmgJV3BZPMcxQhGhR35q0gZ\n" + "Xe1+obHVEL1+501z+vNrwx7Pomg1kEb064efkkAJQ4tIHGzXiJoALtXuOCvJGQ2m\n" + "/AJuR5VY5EdWd+mqnjBQ4nZWlN/IH1bogLlucWDJgN2Y7dPf//////////8CAQID\n" + "ggQFAAKCBAB6skc5bwB1kCSZx9QV53rVicQu8L4Gt1qtYJoHNICF6u0H0vzM0arj\n" + "emLcV6L1h+CVykAUoCTX3EJcClkjE4gi80A6mJ3IZ4FOZObG98lrs/Ha653WpFyG\n" + "hYYGwHEE8i1gRwLK80cDSESkcxZJdB9BVyZpwtpUfrGbkt1Bh7fC33CYvK9Px0CZ\n" + "8LWKii/nyn6q9d6z4veGOgcJI590NEuNnrX5FedC1UkQcG0207YOOFoSXZ5WHOvb\n" + "m+807q8rLt4/YCpN4yzbfknxz4VQgRNchmhRQ4kGiCdmVuiAgIVF55emrNGK6Z0m\n" + "OtnpPo5BjK75yvDfWMURGhbr1TlpK26hxsinZYhcy0KH7HjKHB4i+4MQcMgxlRfj\n" + "8ePBYwEeJtzutP0u6BhdQ7Y2Wh+mdCi1HdvMKuspswpyPVPnvezrLh+xQ7WzatI5\n" + "i1dATcFxfAy88Z7yCCmzXYIl1/iljzATxgORdnNtXjvtT+mcLlDBLQMrmi5ZaRn4\n" + "wJgONdlTQlTRzopKLK5zmnZnVPNYDU2yjI6R5R5KJkI3Q+hdMrs6ssIEpkzED3g4\n" + "kpNABcS9vzGr303mbgfs0HR0Low4NoggmTQVMhmZo1PsKt5cL5cNk60Yirzvm3S+\n" + "k8WxVAuMwcDjBsFRO825FyaAPJ4ZnrPomQIHdsGxkLHvZWNvnryI1/GE9aWNM+5N\n" + "Pk/uhQeatK2zV4+/AmqHEvQkQ5Khd3XIOAt8+BT344cSjCcl5bGl3nz3ry8y0mPo\n" + "DECOvisp5hJkYeDYlW8ai45xDjklah7qekS9BBKpEHW8hMp1OojHrtnfS5MXN+Bf\n" + "imAkw7a0n/9c8q4XfvQLDpOkyWNar+Wq9D4zfHcqu0JAneDwhnS+O1g/lCJYQygg\n" + "pck4RkVz2K3ObjuNYc/VKmdnSZYU9bBKAXUJMOYJi2Gag6IP381tQI26VzBbwEff\n" + "xFAsnkscbztukiknM5bCvSekWphW8t5ghMQbB6/5dROgo5+M5OdG5G2lDa1aKjmL\n" + "urLui37vKOcfvKZm+y0DifTSt2/ljZULtJO5E+Lp/WqWTB8rJLcxFbSfgr9CqgZN\n" + "lIyRF6Wdovi75U5eWfP0uWK7vuc2rfxQtPiEHAC16DrFqUKZN9DprNXjU5mwqf9t\n" + "IWoeXS1uEIHZE2zQee9VPzKXQIOrXNONPdw2DY7a9d3ScFaoxDs3I7YbZ8GrjHum\n" + "eyNf+5LGJqzuvpCzb6defkeWP8sMkdTpby4qM86OW42Jvl27Z9GsPjB3ee6YiHMj\n" + "4BCVsldbYN4iGQqsovsXQagdVFZdHSemeuiByJTcJRKE0pPUhbCpl9ndFTQ7Ah23\n" + "0wF19uLDbk10PhmuiWORmIO27t9Ps6iu\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDsa2048Prikey = "-----BEGIN PRIVATE KEY-----\n" + "MIICXAIBADCCAjUGByqGSM44BAEwggIoAoIBAQDPXEvnKzvLwPGASwVMsFMI4JgW\n" + "FaKAjDi9c194Nt71Fpo3zNPNikXXKoHEqJYRF1EVzzlmkiARhE9hwAESuKgK3oJP\n" + "/Aygovtr5+pwo16E9LqR3/t2Qp2ZENs45BGQ+DrwUr6S55T3Mo3NyMsbr3SDKsZY\n" + "eFnsN2A67i4jbQpVvJL+fAvWUgGuEIXIa5oQJ1LokQ0iBarXVJ5tu+JLVjgqkQnW\n" + "1iWA24xkMq2NOWUDgcWjPxrVW8TPuuaB6cKMKDT6t8zRVrCGBxThF7RBGWWWOYev\n" + "CQ7lbSAkDYZFzKqFt4DRj3NuWXFlrqdxrOHrd74StAA7HuU8i+5T7ExI5ir7Ah0A\n" + "+ujqphLK8rDnXYwlgVE2OouAIPaM/e7VPql9qwKCAQBeSv4sbWm4Ru6j35i2W4+a\n" + "Fq7uSdF5P93xruLI+u4a/h7nZVHbXUP7kET5oNbbSRzmxaSQtlFhDJZMFjSHxAme\n" + "6Cl/sa+RYK0gpDqccWo2+e1QeEv3+4t5HmYevWY7blehaB3ITySHB586E86Rl4+r\n" + "kqvnI7Mh2wFEZGknrRi+oZLTr5PZti2nd+ouPVMNl8l3T6oZcXUO1wUSMFY3yExO\n" + "fh66W2wqp9wvSyVUM7T06MKHQ/e6T2+7VUIXhnorDYldtkWJla4X6zuSaryFeKZo\n" + "XPno390zxFukACbLgM5R/9RqTVynmJc4wx+ixCvei3hB2keHlenGQEVJXJtZf56m\n" + "BB4CHDze5XQTmFMIAFjht3dyZGMtO5PqvxJOnVHwnKk=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDsa3072Prikey = "-----BEGIN PRIVATE KEY-----\n" + "MIIDXgIBADCCAzYGByqGSM44BAEwggMpAoIBgQCjDOJwnOl9/hQ/CviGJvA3BTDA\n" + "IqlmaFJMSQzF4rp28YzW6P2+3ssi/vzGjnA+7O1ZdZV1xchkO0sPDF9lEKGNUnRb\n" + "eM0IgVkfV2Bdjqn7y0o+q6NoiaNLbMuyEiGaNKhzfoP9x8NDlSd+W/d4jwYg+JF0\n" + "4gCXpNXCMatcbviDzYGbun1rL5sTKltApYKCCMtyvf9AcUsN0RyXjo9TSXP750C9\n" + "3T6FeuCsDGXniwtIghIIDCHBOCvkHwEu/zueicAAPaHP9iipgZ3wO33ToaUdYqdl\n" + "8OPFu9JMgKLpJNwT9PhtBf6inOsVb4udVJmXFQ7UHdszo4yDkyUW4ob8qJ1RwKyj\n" + "q3ZfJ5Y2kilbH0Nphpyg3FJyAzDPofhj33sFUfKJkRHwOzf+xwszjKuLbLIjDHvm\n" + "8mudFhzSFqFiKyRqS97lGcK2T4SahSn8lZ+P9kyRZuZCpXw8GJIcbLJSgZWfaQvh\n" + "aI2WMWS8ggQwxn7gz4W5QGQ/R29dIvCZPqr3+qECHQDkpzzLWcDIHmmqIrLZH8Nt\n" + "u+3Q0XQBQtaZOWnVAoIBgQCDuEO0G8cE7n4txT/T17RmzTEILRPc2+2mmvcPFYDc\n" + "uS1mC8838zXU3VM1juVP/vpuTdPi01D7yQIb23jjb77n4roAwsflQvY5fc6sBBOJ\n" + "/BjJcF9CLHRBgTXknYgN4qSZx8+X7/w8A22JEC4u6gMQKLPwnEJdK/fx51tnqVYY\n" + "lK9sTeAuGLdsD5CbJzgqXNRlS0JGGyw2CmGQKwTPybLYQcHnB2ZnYunOSGyrsZB7\n" + "suVlJ5OfLwdN0or06wltu9yv2Tz+74d5Kdessx4sSfgZ4yDtcXLYCKMPJjI2cLH0\n" + "lgZ7msfBYcPmk8L8hPWq2GDWTONdpngdiEk8fRwWsHRM4jvfxoMv1lmoK7F9VTUd\n" + "BLzgYka+/xIIfQB5VBXZrHaGQnbGLZRoWYPHeLuh21wxSwmoB8YFZQs2umOSBJm7\n" + "sJP1UZM7DYCZSe4QRmsTrwdhlvdd4tNsxHKGnZXMQNBgSJGPL5ag5+8Z6wEPoIo4\n" + "0EO1ILw13ufx/qBlcNZjLZQEHwIdAMr8b91HR/l73ek2RWENJsV0YLng7R1mj+Jm\n" + "sbg=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testDsa2048PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIDQjCCAjUGByqGSM44BAEwggIoAoIBAQDPXEvnKzvLwPGASwVMsFMI4JgWFaKA\n" + "jDi9c194Nt71Fpo3zNPNikXXKoHEqJYRF1EVzzlmkiARhE9hwAESuKgK3oJP/Ayg\n" + "ovtr5+pwo16E9LqR3/t2Qp2ZENs45BGQ+DrwUr6S55T3Mo3NyMsbr3SDKsZYeFns\n" + "N2A67i4jbQpVvJL+fAvWUgGuEIXIa5oQJ1LokQ0iBarXVJ5tu+JLVjgqkQnW1iWA\n" + "24xkMq2NOWUDgcWjPxrVW8TPuuaB6cKMKDT6t8zRVrCGBxThF7RBGWWWOYevCQ7l\n" + "bSAkDYZFzKqFt4DRj3NuWXFlrqdxrOHrd74StAA7HuU8i+5T7ExI5ir7Ah0A+ujq\n" + "phLK8rDnXYwlgVE2OouAIPaM/e7VPql9qwKCAQBeSv4sbWm4Ru6j35i2W4+aFq7u\n" + "SdF5P93xruLI+u4a/h7nZVHbXUP7kET5oNbbSRzmxaSQtlFhDJZMFjSHxAme6Cl/\n" + "sa+RYK0gpDqccWo2+e1QeEv3+4t5HmYevWY7blehaB3ITySHB586E86Rl4+rkqvn\n" + "I7Mh2wFEZGknrRi+oZLTr5PZti2nd+ouPVMNl8l3T6oZcXUO1wUSMFY3yExOfh66\n" + "W2wqp9wvSyVUM7T06MKHQ/e6T2+7VUIXhnorDYldtkWJla4X6zuSaryFeKZoXPno\n" + "390zxFukACbLgM5R/9RqTVynmJc4wx+ixCvei3hB2keHlenGQEVJXJtZf56mA4IB\n" + "BQACggEAH9bSRnDNxEOC2oQl7dUO++NWwF4hpmx7z6zeYSN/ViGaFkl0cytASaKw\n" + "sKXtKjmwQogxNO/eE2q2R0UsB8CCtyJ6LeiIo6yv81gWopI+ZtFgr67vFHcx8q8D\n" + "jlkmy6gvt7iB8cPn8Mp95KDPHqlqgeMguxZs5uLucRJ0WS1YFWMqTGiCuH4SYrph\n" + "NtmTNScnlxco4vwxLWRjejWpy+PJF+6XpvSnIp88ARTrpqPEy9xcM1Cr5NJqO3qT\n" + "C4Gyt3FtSTC/R2iRm3IrLHMoJjSdbgXnX9LhvVOOzWyPtxe78/tUh3NsC0kI0IdG\n" + "HSTT3iq3yULgcAmq/+o02x4FYZq/2A==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testDsa3072PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIIEwzCCAzYGByqGSM44BAEwggMpAoIBgQCjDOJwnOl9/hQ/CviGJvA3BTDAIqlm\n" + "aFJMSQzF4rp28YzW6P2+3ssi/vzGjnA+7O1ZdZV1xchkO0sPDF9lEKGNUnRbeM0I\n" + "gVkfV2Bdjqn7y0o+q6NoiaNLbMuyEiGaNKhzfoP9x8NDlSd+W/d4jwYg+JF04gCX\n" + "pNXCMatcbviDzYGbun1rL5sTKltApYKCCMtyvf9AcUsN0RyXjo9TSXP750C93T6F\n" + "euCsDGXniwtIghIIDCHBOCvkHwEu/zueicAAPaHP9iipgZ3wO33ToaUdYqdl8OPF\n" + "u9JMgKLpJNwT9PhtBf6inOsVb4udVJmXFQ7UHdszo4yDkyUW4ob8qJ1RwKyjq3Zf\n" + "J5Y2kilbH0Nphpyg3FJyAzDPofhj33sFUfKJkRHwOzf+xwszjKuLbLIjDHvm8mud\n" + "FhzSFqFiKyRqS97lGcK2T4SahSn8lZ+P9kyRZuZCpXw8GJIcbLJSgZWfaQvhaI2W\n" + "MWS8ggQwxn7gz4W5QGQ/R29dIvCZPqr3+qECHQDkpzzLWcDIHmmqIrLZH8Ntu+3Q\n" + "0XQBQtaZOWnVAoIBgQCDuEO0G8cE7n4txT/T17RmzTEILRPc2+2mmvcPFYDcuS1m\n" + "C8838zXU3VM1juVP/vpuTdPi01D7yQIb23jjb77n4roAwsflQvY5fc6sBBOJ/BjJ\n" + "cF9CLHRBgTXknYgN4qSZx8+X7/w8A22JEC4u6gMQKLPwnEJdK/fx51tnqVYYlK9s\n" + "TeAuGLdsD5CbJzgqXNRlS0JGGyw2CmGQKwTPybLYQcHnB2ZnYunOSGyrsZB7suVl\n" + "J5OfLwdN0or06wltu9yv2Tz+74d5Kdessx4sSfgZ4yDtcXLYCKMPJjI2cLH0lgZ7\n" + "msfBYcPmk8L8hPWq2GDWTONdpngdiEk8fRwWsHRM4jvfxoMv1lmoK7F9VTUdBLzg\n" + "Yka+/xIIfQB5VBXZrHaGQnbGLZRoWYPHeLuh21wxSwmoB8YFZQs2umOSBJm7sJP1\n" + "UZM7DYCZSe4QRmsTrwdhlvdd4tNsxHKGnZXMQNBgSJGPL5ag5+8Z6wEPoIo40EO1\n" + "ILw13ufx/qBlcNZjLZQDggGFAAKCAYBo6EVks/SjgbT0WYsrCIZbvKPkqccsg+Fd\n" + "veKz9eUpJpo93EfZgDqMNka8zSzo4vO7fYJPgxw+YkPVCzdtCqxKJLvDeSsogQ/j\n" + "1LGyuVoOdXU4E1SHgKTtkviKU2zCJoSE6/gH3i9cfaVvBpr1kiQV5isDJb02Wqh8\n" + "bq1skTVoy+eg6x75mPrd5eRmzQiDOmWtkwfxfBC2ybeXBsS39DsqDXAfTRC0kaK8\n" + "Od2KSM0btuZatIo28Qw65io2ABbTW973BwJ3uKhWgaVoBIwzvsyYd6FfSpWEQ36A\n" + "u7kiGH5QltjvTVtoOlSnV8U+g2S+6X2mMhfVz6TUOWf1E4d6jLZ9Oet5gap8aJ2M\n" + "NbYpNxnyfFIG9q0RAVqPUAddvW5hOypCeIXUuLIz2c+tHIvWcwlOomrv0e4K1jgP\n" + "Egh1ccqwqqiM+Pz57SAIYdsN+sDxanWK9IUBpNQmCtbhRhVgt8PzbFVoBKs5wFbj\n" + "J5CGPcuzhta1Ju41XMtRHHigBtL62r4=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP160r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MGQCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEBBEkwRwIBAQQUASO/LfZI7/oU61jD\n" + "jI3iN3daCsKhLAMqAAR9QXIl11ePlAzVlwjLUnkKjxX6LBAU4Q0sOo1eeDM+nEg5\n" + "XenI3o1+\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP160r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MEIwFAYHKoZIzj0CAQYJKyQDAwIIAQEBAyoABH1BciXXV4+UDNWXCMtSeQqPFfos\n" + "EBThDSw6jV54Mz6cSDld6cjejX4=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP160t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MGQCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQECBEkwRwIBAQQU3/XiFisN/54Kj4nQ\n" + "Bwjr1dceZQihLAMqAATKWOgm/tH+UYnAv8hs/Y/D34fMv4BwU4k3/Z+gRBKRN4cy\n" + "ypd5NiES\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP160t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MEIwFAYHKoZIzj0CAQYJKyQDAwIIAQECAyoABMpY6Cb+0f5RicC/yGz9j8Pfh8y/\n" + "gHBTiTf9n6BEEpE3hzLKl3k2IRI=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP192r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MHACAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEDBFUwUwIBAQQYZJ2mohQak6UuCZdW\n" + "Ox8uUsOp70Pg2T0+oTQDMgAEezNHhaP+k9qgeQ/9ZHAc/AhkWrGNJ8AjwFqrj4lc\n" + "EyDnCz3QxK3MEmfPxkhlNXWb\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP192r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MEowFAYHKoZIzj0CAQYJKyQDAwIIAQEDAzIABHszR4Wj/pPaoHkP/WRwHPwIZFqx\n" + "jSfAI8Baq4+JXBMg5ws90MStzBJnz8ZIZTV1mw==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP192t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MHACAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEEBFUwUwIBAQQYG9Qnpo0Mnsc038+F\n" + "8cL9eend4xNz6blPoTQDMgAECrDcmHkXtKe1+TKqYtM2jfe805qYBR7kgBWmEmJN\n" + "KAfv8Oo+/1u/VpNe2nYBURRn\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP192t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MEowFAYHKoZIzj0CAQYJKyQDAwIIAQEEAzIABAqw3Jh5F7SntfkyqmLTNo33vNOa\n" + "mAUe5IAVphJiTSgH7/DqPv9bv1aTXtp2AVEUZw==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP224r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MHwCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEFBGEwXwIBAQQcjRIweUszgw6kye8e\n" + "uH+EDixtMWACgjAFKLlD86E8AzoABKJPILw4pJ703KZWzwCiU2WIZgaxlHo3M/LI\n" + "hOuGsmvnaBmH6nfTt4E7NqHkgBnJVNTmELXpPDt2\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP224r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFIwFAYHKoZIzj0CAQYJKyQDAwIIAQEFAzoABKJPILw4pJ703KZWzwCiU2WIZgax\n" + "lHo3M/LIhOuGsmvnaBmH6nfTt4E7NqHkgBnJVNTmELXpPDt2\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP224t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MHwCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEGBGEwXwIBAQQc0FrhunNRyAF63WWu\n" + "RnlazhSV2vURHyWcGu6deKE8AzoABIdtC73AhzV0Jr90EHl9DHuyQfsrb9917sCj\n" + "+4YGoKqXTKp8Ww4dc1dDIxd9FKyz9J///x1RUqUn\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP224t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFIwFAYHKoZIzj0CAQYJKyQDAwIIAQEGAzoABIdtC73AhzV0Jr90EHl9DHuyQfsr\n" + "b9917sCj+4YGoKqXTKp8Ww4dc1dDIxd9FKyz9J///x1RUqUn\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP256r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGIAgEAMBQGByqGSM49AgEGCSskAwMCCAEBBwRtMGsCAQEEIGEWmKHlX2Q7RNcn\n" + "TjcbiQO83eOZdeohwj6GrZTswNZYoUQDQgAELXkxbTULz0F0MP9if30WZ2SUw3Sz\n" + "Oht9darQcWO6fzUlHzJPAz//wv+narhYYYGO9c9K7YTGSUPA9x3G4l31rA==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP256r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFowFAYHKoZIzj0CAQYJKyQDAwIIAQEHA0IABC15MW01C89BdDD/Yn99FmdklMN0\n" + "szobfXWq0HFjun81JR8yTwM//8L/p2q4WGGBjvXPSu2ExklDwPcdxuJd9aw=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP256t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGIAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCARtMGsCAQEEICKa3/xdoohLWjrn\n" + "mR/5Iyb8yyb6FPAa9R4vTa6x53b+oUQDQgAEgeCO46sHVnF8StJg7SiKW/Nwbw76\n" + "Nai8MrlYN8axQN9oEgwrTNVzu0M4X2fquIxI8i52Rp+/iPL50zE8UI4RKA==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP256t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFowFAYHKoZIzj0CAQYJKyQDAwIIAQEIA0IABIHgjuOrB1ZxfErSYO0oilvzcG8O\n" + "+jWovDK5WDfGsUDfaBIMK0zVc7tDOF9n6riMSPIudkafv4jy+dMxPFCOESg=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP320r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGiAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCQSBhjCBgwIBAQQoQg1ccOHTcKft\n" + "H7HYc+bMzIqlWs76bfL9ie1Z7AvZaCHTxdvkXkSnzKFUA1IABA+GdgqTHGQORU7c\n" + "oz/8036686oDnSs8kMjNQ4GIdGHcwXiurGviJmO/T+yJAU2wqiTefWGjOpNVzOMJ\n" + "HHnad3xgbzrevv5ajO6PUHeI14OP\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP320r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MGowFAYHKoZIzj0CAQYJKyQDAwIIAQEJA1IABA+GdgqTHGQORU7coz/8036686oD\n" + "nSs8kMjNQ4GIdGHcwXiurGviJmO/T+yJAU2wqiTefWGjOpNVzOMJHHnad3xgbzre\n" + "vv5ajO6PUHeI14OP\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP320t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGiAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCgSBhjCBgwIBAQQoNBUB9bYEND/J\n" + "Aa/5LWOwPFVAteMc06veS4FgGuyhTXxwGFJuwvGx56FUA1IABDdabgr6v4yG2hLZ\n" + "2zTxP2+vKDwVJaHvBQ8StEkkfYKzKus5hUILOQTEbpi6/ODPw0ZRC1+uK87IuPMu\n" + "1DnWIRvDUrSFCcjURCTAwudMTt5y\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP320t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MGowFAYHKoZIzj0CAQYJKyQDAwIIAQEKA1IABDdabgr6v4yG2hLZ2zTxP2+vKDwV\n" + "JaHvBQ8StEkkfYKzKus5hUILOQTEbpi6/ODPw0ZRC1+uK87IuPMu1DnWIRvDUrSF\n" + "CcjURCTAwudMTt5y\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP384r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIG6AgEAMBQGByqGSM49AgEGCSskAwMCCAEBCwSBnjCBmwIBAQQwf+M859VdL3Cx\n" + "DUQ6xzEpPbgmHhlMa9veRNok/VlKFwHs7gUpirvA+vzCz1sJA0ePoWQDYgAEgYsV\n" + "W0pKIDXz4qWgvqkFLD6yB+99GvXDnMKRQPIHcSOfAnThZtr5LJH/xXMNs29aez3a\n" + "TqgYmVtiAQgM+C6shAaqqj6qZoE0ACSgemVKHxV065JStQts9xfqhK2QOey9\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP384r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MHowFAYHKoZIzj0CAQYJKyQDAwIIAQELA2IABIGLFVtKSiA18+KloL6pBSw+sgfv\n" + "fRr1w5zCkUDyB3EjnwJ04Wba+SyR/8VzDbNvWns92k6oGJlbYgEIDPgurIQGqqo+\n" + "qmaBNAAkoHplSh8VdOuSUrULbPcX6oStkDnsvQ==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP384t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIG6AgEAMBQGByqGSM49AgEGCSskAwMCCAEBDASBnjCBmwIBAQQwaPOGmvKk9UPa\n" + "GnpoWTpvs2gmq5C1CC8pMc8aVFPWY4yhUszcnYiIuIMfs+AzMo6CoWQDYgAEdemX\n" + "VIj45zsc/28xYiSObxmuf4OskgIvBrptXx8DwJMOmZvFawXswxZErzv13gvmcPMd\n" + "rif01/fGgrr/QTQAKx8l/5TkECkHdOflHS84Wy2h1mkbb3KFJH7Opm5JMmtw\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP384t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MHowFAYHKoZIzj0CAQYJKyQDAwIIAQEMA2IABHXpl1SI+Oc7HP9vMWIkjm8Zrn+D\n" + "rJICLwa6bV8fA8CTDpmbxWsF7MMWRK879d4L5nDzHa4n9Nf3xoK6/0E0ACsfJf+U\n" + "5BApB3Tn5R0vOFstodZpG29yhSR+zqZuSTJrcA==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP512r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIHsAgEAMBQGByqGSM49AgEGCSskAwMCCAEBDQSB0DCBzQIBAQRAjQ8+FR54Dggv\n" + "o5bICxr+k+6fjjeakaYFxwaqlVtznmLdX9WqantFAld3mSRI0fEwa8quplRS/SO1\n" + "egRx/i/CbKGBhQOBggAEdtNym0AqquTwWqRH8ardukuoopQQu3dbq30IWsZfyx/h\n" + "ZLMNJWpLVMKcIg0F/qccFlqKvj3kMy6c7keIAMkBKXeCJ+6NKM3cgcKr1crfvagC\n" + "mbAjSHsKXQRLIk3WCxL4xqXk+GC/Na64lsUnqDIw/ieztxmhkT9O5zLdW6qAKhI=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP512r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDQOBggAEdtNym0AqquTwWqRH8ardukuo\n" + "opQQu3dbq30IWsZfyx/hZLMNJWpLVMKcIg0F/qccFlqKvj3kMy6c7keIAMkBKXeC\n" + "J+6NKM3cgcKr1crfvagCmbAjSHsKXQRLIk3WCxL4xqXk+GC/Na64lsUnqDIw/iez\n" + "txmhkT9O5zLdW6qAKhI=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccBrainpoolP512t1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIHsAgEAMBQGByqGSM49AgEGCSskAwMCCAEBDgSB0DCBzQIBAQRAhSMiRfKXVUGS\n" + "hMiCfkdszV0TmdWib5WIoNFKyHQGgtt8kZcXl5NX84SsoO28leLDJ9fSd1qV/Dwq\n" + "+INCiNKnGaGBhQOBggAEKGhHCsQ5qabxssAoCZiEZT9wxdTOliHqv+mStkwQRPZD\n" + "Or4uSUqGTQHXUWY/9+J3fMnvws7uf9p9GnRB9rpHL2K/NkiviW+hX+ikIuyT7nGr\n" + "jPT8olwleVaidVbgPjLtliZV98evrcZKZ/x1plcWX7l8I2Bhg5845fximjWUvQU=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccBrainpoolP512t1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDgOBggAEKGhHCsQ5qabxssAoCZiEZT9w\n" + "xdTOliHqv+mStkwQRPZDOr4uSUqGTQHXUWY/9+J3fMnvws7uf9p9GnRB9rpHL2K/\n" + "NkiviW+hX+ikIuyT7nGrjPT8olwleVaidVbgPjLtliZV98evrcZKZ/x1plcWX7l8\n" + "I2Bhg5845fximjWUvQU=\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccPrime256v1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgrwZLoHLb9awzKiT1\n" + "5/FXrItjgIExhDon3mGVrVHllqahRANCAAQCOkE1Xx5YKUjKGaN86zL5JO6irKe9\n" + "XXjC3kashJ7fYzLkrkIuHyuqEM7hvmw0F7w/DrUkonPgCN+t395C9/EW\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccPrime256v1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEAjpBNV8eWClIyhmjfOsy+STuoqyn\n" + "vV14wt5GrISe32My5K5CLh8rqhDO4b5sNBe8Pw61JKJz4Ajfrd/eQvfxFg==\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccSecp384r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDBq2KueaDvMuB0n7Wd3\n" + "s5vThqu5wxBIdN3BzE12+RzqL+Q+iqzPuHS4YE11syurz9ahZANiAAQ86CZ+Fvmm\n" + "w36OiBIx412pYe+HWd2TBCkWr5p6tIKcdszG0AhMxPkgzjAtrSUHg+/rsd5TWSdx\n" + "B0SmbWQTcukqrdb8ITAkgmk4HUjQ85TjWXDokYK5wXWE0fWV5BpzkZ4=\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccSecp384r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEPOgmfhb5psN+jogSMeNdqWHvh1ndkwQp\n" + "Fq+aerSCnHbMxtAITMT5IM4wLa0lB4Pv67HeU1kncQdEpm1kE3LpKq3W/CEwJIJp\n" + "OB1I0POU41lw6JGCucF1hNH1leQac5Ge\n" + "-----END PUBLIC KEY-----\n"; + +static string g_testEccSecp521r1PriKey = "-----BEGIN PRIVATE KEY-----\n" + "MIHuAgEAMBAGByqGSM49AgEGBSuBBAAjBIHWMIHTAgEBBEIByYx3SSpA7rou1Fpa\n" + "I4ySKDxaJHPXrlM/C/0WFG9UboT6vjvpp3BA4CrkE5FH8hP3ouUbkAFDMvSJbkL1\n" + "paUdOB2hgYkDgYYABACEkXDyF6CWltw6eN83x4x0NbZpncw2iwuZBC/nIR9+scXp\n" + "+Gj48ft8F9Er+CrtQEvNwz1PGWVTk+dnpJ/ztlfu4ADhyb5B9GWtwNi4D+rgHtYX\n" + "LlsthM8GGlAbuMIV0y/QTqqtwYFEJwBVwopsVn1rjWnFxIaZRcEJa6dwM58+sLYc\n" + "Ng==\n" + "-----END PRIVATE KEY-----\n"; + +static string g_testEccSecp521r1PubKey = "-----BEGIN PUBLIC KEY-----\n" + "MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQAhJFw8heglpbcOnjfN8eMdDW2aZ3M\n" + "NosLmQQv5yEffrHF6fho+PH7fBfRK/gq7UBLzcM9TxllU5PnZ6Sf87ZX7uAA4cm+\n" + "QfRlrcDYuA/q4B7WFy5bLYTPBhpQG7jCFdMv0E6qrcGBRCcAVcKKbFZ9a41pxcSG\n" + "mUXBCWuncDOfPrC2HDY=\n" + "-----END PUBLIC KEY-----\n"; + +static void asyKeyConvertPemTest(const char *algoName, const char *pubKey, const char *priKey) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertPemKey(generator, nullptr, pubKey, priKey, &dupKeyPair); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(dupKeyPair, nullptr); + + HcfKeyPair *dupKeyPair2 = nullptr; + res = generator->convertPemKey(generator, nullptr, nullptr, priKey, &dupKeyPair2); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(dupKeyPair2, nullptr); + + HcfKeyPair *dupKeyPair3 = nullptr; + res = generator->convertPemKey(generator, nullptr, pubKey, nullptr, &dupKeyPair3); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(dupKeyPair3, nullptr); + + HcfObjDestroy(dupKeyPair); + HcfObjDestroy(dupKeyPair2); + HcfObjDestroy(dupKeyPair3); + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest001, TestSize.Level0) +{ + asyKeyConvertPemTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyConvertPemTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyConvertPemTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyConvertPemTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyConvertPemTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyConvertPemTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + + asyKeyConvertPemTest("DH_ffdhe2048", g_testDhFfdhe2048PubKey.c_str(), g_testDhFfdhe2048PriKey.c_str()); + asyKeyConvertPemTest("DH_ffdhe3072", g_testDhFfdhe3072PubKey.c_str(), g_testDhFfdhe3072PriKey.c_str()); + asyKeyConvertPemTest("DH_ffdhe4096", g_testDhFfdhe4096PubKey.c_str(), g_testDhFfdhe4096PriKey.c_str()); + asyKeyConvertPemTest("DH_ffdhe6144", g_testDhFfdhe6144PubKey.c_str(), g_testDhFfdhe6144PriKey.c_str()); + asyKeyConvertPemTest("DH_ffdhe8192", g_testDhFfdhe8192PubKey.c_str(), g_testDhFfdhe8192PriKey.c_str()); + asyKeyConvertPemTest("DH_modp2048", g_testDhModp2048PubKey.c_str(), g_testDhModp2048PriKey.c_str()); + asyKeyConvertPemTest("DH_modp3072", g_testDhModp3072PubKey.c_str(), g_testDhModp3072PriKey.c_str()); + asyKeyConvertPemTest("DH_modp4096", g_testDhModp4096PubKey.c_str(), g_testDhModp4096PriKey.c_str()); + asyKeyConvertPemTest("DH_modp6144", g_testDhModp6144PubKey.c_str(), g_testDhModp6144PriKey.c_str()); + asyKeyConvertPemTest("DH_modp8192", g_testDhModp8192PubKey.c_str(), g_testDhModp8192PriKey.c_str()); + + asyKeyConvertPemTest("DSA2048", g_testDsa2048PubKey.c_str(), g_testDsa2048Prikey.c_str()); + asyKeyConvertPemTest("DSA3072", g_testDsa3072PubKey.c_str(), g_testDsa3072Prikey.c_str()); + + asyKeyConvertPemTest("ECC_BrainPoolP160r1", g_testEccBrainpoolP160r1PubKey.c_str(), g_testEccBrainpoolP160r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP160t1", g_testEccBrainpoolP160t1PubKey.c_str(), g_testEccBrainpoolP160t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP192r1", g_testEccBrainpoolP192r1PubKey.c_str(), g_testEccBrainpoolP192r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP192t1", g_testEccBrainpoolP192t1PubKey.c_str(), g_testEccBrainpoolP192t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP224r1", g_testEccBrainpoolP224r1PubKey.c_str(), g_testEccBrainpoolP224r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP224t1", g_testEccBrainpoolP224t1PubKey.c_str(), g_testEccBrainpoolP224t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP256r1", g_testEccBrainpoolP256r1PubKey.c_str(), g_testEccBrainpoolP256r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP256t1", g_testEccBrainpoolP256t1PubKey.c_str(), g_testEccBrainpoolP256t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP320r1", g_testEccBrainpoolP320r1PubKey.c_str(), g_testEccBrainpoolP320r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP320t1", g_testEccBrainpoolP320t1PubKey.c_str(), g_testEccBrainpoolP320t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP384r1", g_testEccBrainpoolP384r1PubKey.c_str(), g_testEccBrainpoolP384r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP384t1", g_testEccBrainpoolP384t1PubKey.c_str(), g_testEccBrainpoolP384t1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP512r1", g_testEccBrainpoolP512r1PubKey.c_str(), g_testEccBrainpoolP512r1PriKey.c_str()); + asyKeyConvertPemTest("ECC_BrainPoolP512t1", g_testEccBrainpoolP512t1PubKey.c_str(), g_testEccBrainpoolP512t1PriKey.c_str()); + asyKeyConvertPemTest("ECC256", g_testEccPrime256v1PubKey.c_str(), g_testEccPrime256v1PriKey.c_str()); + asyKeyConvertPemTest("ECC384", g_testEccSecp384r1PubKey.c_str(), g_testEccSecp384r1PriKey.c_str()); + asyKeyConvertPemTest("ECC521", g_testEccSecp521r1PubKey.c_str(), g_testEccSecp521r1PriKey.c_str()); +} + +static void asyKeyPemParamNullErrorTest(const char *algoName, const char *pubKey, const char *priKey) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertPemKey(generator, nullptr, nullptr, nullptr, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(nullptr, nullptr, pubKey, priKey, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(generator, nullptr, pubKey, priKey, nullptr); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + HcfObjDestroy(generator); +} + +// test ConvertPemKey parma is null +HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest002, TestSize.Level0) +{ + asyKeyPemParamNullErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamNullErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamNullErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamNullErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamNullErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamNullErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); +} + +static void asyKeyPemParamFormatErrorTest(const char *algoName, const char *pubKey, const char *priKey) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertPemKey(generator, nullptr, "pubkey", priKey, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(generator, nullptr, pubKey, "prikey", &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(generator, nullptr, "pubkey", "prikey", &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + HcfObjDestroy(generator); +} + +// test ConvertPemKey pubkey and prikey is invalid +HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest003, TestSize.Level0) +{ + asyKeyPemParamFormatErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamFormatErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamFormatErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamFormatErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamFormatErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamFormatErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); +} + +static void asyKeyPemParamMatchErrorTest(const char *algoName, const char *pubKey, const char *priKey) +{ + HcfAsyKeyGenerator *generator = nullptr; + HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); + EXPECT_EQ(res, HCF_SUCCESS); + EXPECT_NE(generator, nullptr); + + HcfKeyPair *dupKeyPair = nullptr; + res = generator->convertPemKey(generator, nullptr, pubKey, priKey, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(generator, nullptr, nullptr, priKey, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + res = generator->convertPemKey(generator, nullptr, pubKey, nullptr, &dupKeyPair); + EXPECT_NE(res, HCF_SUCCESS); + EXPECT_EQ(dupKeyPair, nullptr); + + HcfObjDestroy(generator); +} + +HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest004, TestSize.Level0) +{ + asyKeyPemParamMatchErrorTest("SM2_256", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("SM2_256", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("SM2_256", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchErrorTest("SM2_256", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchErrorTest("SM2_256", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchErrorTest("X25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchErrorTest("X25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("X25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchErrorTest("X25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchErrorTest("X25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchErrorTest("Ed25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchErrorTest("Ed25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("Ed25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchErrorTest("Ed25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchErrorTest("Ed25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchErrorTest("ECC224", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchErrorTest("ECC224", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("ECC224", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("ECC224", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchErrorTest("ECC224", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DSA1024", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DSA1024", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DSA1024", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DSA1024", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DSA1024", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DH_modp1536", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DH_modp1536", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DH_modp1536", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DH_modp1536", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchErrorTest("DH_modp1536", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); +} +} -- Gitee From 7180dcf392e4d9b81157568908a751dc3abcfcc1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=90=8C=E8=90=8C=E8=90=8C=E6=96=B0?= Date: Sat, 27 Jul 2024 08:52:12 +0800 Subject: [PATCH 03/32] add new funcs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 萌萌萌新 --- frameworks/cj/BUILD.gn | 19 +- .../cj/include/asy_key_generator_impl.h | 34 + .../cj/include/asy_key_spec_generator_impl.h | 34 + frameworks/cj/{src => include}/cipher_impl.h | 2 +- frameworks/cj/{src => include}/crypto_ffi.h | 127 +- frameworks/cj/include/dh_key_util_impl.h | 31 + frameworks/cj/include/ecc_key_util_impl.h | 33 + frameworks/cj/include/kdf_impl.h | 39 + frameworks/cj/include/key_agreement_impl.h | 37 + frameworks/cj/{src => include}/key_impl.h | 1 + frameworks/cj/include/key_pair_impl.h | 36 + frameworks/cj/{src => include}/mac_impl.h | 2 + frameworks/cj/{src => include}/md_impl.h | 2 + frameworks/cj/include/pri_key_impl.h | 33 + frameworks/cj/include/pub_key_impl.h | 33 + frameworks/cj/{src => include}/random_impl.h | 2 + frameworks/cj/{src => include}/sign_impl.h | 9 + frameworks/cj/include/sm2_crypto_util_impl.h | 31 + .../sym_key_generator_impl.h} | 5 +- .../symkey_impl.h => include/sym_key_impl.h} | 6 +- frameworks/cj/include/verify_impl.h | 43 + ...o_utils.cpp => asy_key_generator_impl.cpp} | 60 +- .../cj/src/asy_key_spec_generator_impl.cpp | 34 + frameworks/cj/src/cipher_impl.cpp | 17 +- frameworks/cj/src/crypto_ffi.cpp | 1129 ++++++++++++++++- frameworks/cj/src/dh_key_util_impl.cpp | 31 + frameworks/cj/src/ecc_key_util_impl.cpp | 45 + frameworks/cj/src/kdf_impl.cpp | 44 + frameworks/cj/src/key_agreement_impl.cpp | 47 + frameworks/cj/src/key_impl.cpp | 2 - frameworks/cj/src/key_pair_impl.cpp | 36 + frameworks/cj/src/mac_impl.cpp | 2 - frameworks/cj/src/md_impl.cpp | 2 - .../src/{crypto_utils.h => pri_key_impl.cpp} | 23 +- frameworks/cj/src/pub_key_impl.cpp | 28 + frameworks/cj/src/random_impl.cpp | 2 - frameworks/cj/src/sign_impl.cpp | 78 +- frameworks/cj/src/sm2_crypto_util_impl.cpp | 38 + ...or_impl.cpp => sym_key_generator_impl.cpp} | 4 +- .../src/{symkey_impl.cpp => sym_key_impl.cpp} | 4 +- frameworks/cj/src/verify_impl.cpp | 96 ++ 41 files changed, 2173 insertions(+), 108 deletions(-) create mode 100644 frameworks/cj/include/asy_key_generator_impl.h create mode 100644 frameworks/cj/include/asy_key_spec_generator_impl.h rename frameworks/cj/{src => include}/cipher_impl.h (92%) rename frameworks/cj/{src => include}/crypto_ffi.h (31%) create mode 100644 frameworks/cj/include/dh_key_util_impl.h create mode 100644 frameworks/cj/include/ecc_key_util_impl.h create mode 100644 frameworks/cj/include/kdf_impl.h create mode 100644 frameworks/cj/include/key_agreement_impl.h rename frameworks/cj/{src => include}/key_impl.h (95%) create mode 100644 frameworks/cj/include/key_pair_impl.h rename frameworks/cj/{src => include}/mac_impl.h (93%) rename frameworks/cj/{src => include}/md_impl.h (93%) create mode 100644 frameworks/cj/include/pri_key_impl.h create mode 100644 frameworks/cj/include/pub_key_impl.h rename frameworks/cj/{src => include}/random_impl.h (93%) rename frameworks/cj/{src => include}/sign_impl.h (68%) create mode 100644 frameworks/cj/include/sm2_crypto_util_impl.h rename frameworks/cj/{src/symkey_generator_impl.h => include/sym_key_generator_impl.h} (90%) rename frameworks/cj/{src/symkey_impl.h => include/sym_key_impl.h} (88%) create mode 100644 frameworks/cj/include/verify_impl.h rename frameworks/cj/src/{crypto_utils.cpp => asy_key_generator_impl.cpp} (61%) create mode 100644 frameworks/cj/src/asy_key_spec_generator_impl.cpp create mode 100644 frameworks/cj/src/dh_key_util_impl.cpp create mode 100644 frameworks/cj/src/ecc_key_util_impl.cpp create mode 100644 frameworks/cj/src/kdf_impl.cpp create mode 100644 frameworks/cj/src/key_agreement_impl.cpp create mode 100644 frameworks/cj/src/key_pair_impl.cpp rename frameworks/cj/src/{crypto_utils.h => pri_key_impl.cpp} (67%) create mode 100644 frameworks/cj/src/pub_key_impl.cpp create mode 100644 frameworks/cj/src/sm2_crypto_util_impl.cpp rename frameworks/cj/src/{symkey_generator_impl.cpp => sym_key_generator_impl.cpp} (94%) rename frameworks/cj/src/{symkey_impl.cpp => sym_key_impl.cpp} (92%) create mode 100644 frameworks/cj/src/verify_impl.cpp diff --git a/frameworks/cj/BUILD.gn b/frameworks/cj/BUILD.gn index 72d493a..b096c56 100644 --- a/frameworks/cj/BUILD.gn +++ b/frameworks/cj/BUILD.gn @@ -16,7 +16,8 @@ import("//base/security/crypto_framework/frameworks/frameworks.gni") import("//build/ohos.gni") ohos_shared_library("cj_cryptoframework_ffi") { - include_dirs = framework_inc_path + include_dirs = [ "include" ] + include_dirs += framework_inc_path if (os_level == "standard") { sanitize = { @@ -48,16 +49,26 @@ ohos_shared_library("cj_cryptoframework_ffi") { "napi:cj_bind_native", ] sources = [ + "src/asy_key_generator_impl.cpp", + "src/asy_key_spec_generator_impl.cpp", "src/cipher_impl.cpp", "src/crypto_ffi.cpp", - "src/crypto_utils.cpp", + "src/dh_key_util_impl.cpp", + "src/ecc_key_util_impl.cpp", + "src/kdf_impl.cpp", + "src/key_agreement_impl.cpp", "src/key_impl.cpp", + "src/key_pair_impl.cpp", "src/mac_impl.cpp", "src/md_impl.cpp", + "src/pri_key_impl.cpp", + "src/pub_key_impl.cpp", "src/random_impl.cpp", "src/sign_impl.cpp", - "src/symkey_generator_impl.cpp", - "src/symkey_impl.cpp", + "src/sm2_crypto_util_impl.cpp", + "src/sym_key_generator_impl.cpp", + "src/sym_key_impl.cpp", + "src/verify_impl.cpp", ] } else { defines += [ "PREVIEWER" ] diff --git a/frameworks/cj/include/asy_key_generator_impl.h b/frameworks/cj/include/asy_key_generator_impl.h new file mode 100644 index 0000000..c03ae02 --- /dev/null +++ b/frameworks/cj/include/asy_key_generator_impl.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef ASY_KEY_GENERATOR_IMPL_H +#define ASY_KEY_GENERATOR_IMPL_H + +#include "asy_key_generator.h" +#include "ffi_remote_data.h" + +namespace OHOS { +namespace CryptoFramework { +class AsyKeyGeneratorImpl : public OHOS::FFI::FFIData { + DECL_TYPE(AsyKeyGeneratorImpl, OHOS::FFI::FFIData) +public: + explicit AsyKeyGeneratorImpl(HcfAsyKeyGenerator *generator); + ~AsyKeyGeneratorImpl(); + HcfAsyKeyGenerator *GetAsyKeyGenerator(); +private: + HcfAsyKeyGenerator *generator_ = nullptr; +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/include/asy_key_spec_generator_impl.h b/frameworks/cj/include/asy_key_spec_generator_impl.h new file mode 100644 index 0000000..d1b685f --- /dev/null +++ b/frameworks/cj/include/asy_key_spec_generator_impl.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef ASY_KEY_SPEC_GENERATOR_IMPL_H +#define ASY_KEY_SPEC_GENERATOR_IMPL_H + +#include "asy_key_generator.h" +#include "ffi_remote_data.h" + +namespace OHOS { +namespace CryptoFramework { +class AsyKeyGeneratorBySpecImpl : public OHOS::FFI::FFIData { + DECL_TYPE(AsyKeyGeneratorBySpecImpl, OHOS::FFI::FFIData) +public: + explicit AsyKeyGeneratorBySpecImpl(HcfAsyKeyGeneratorBySpec *generator); + ~AsyKeyGeneratorBySpecImpl(); + HcfAsyKeyGeneratorBySpec *GetAsyKeyGeneratorBySpec(); +private: + HcfAsyKeyGeneratorBySpec *generator_ = nullptr; +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/src/cipher_impl.h b/frameworks/cj/include/cipher_impl.h similarity index 92% rename from frameworks/cj/src/cipher_impl.h rename to frameworks/cj/include/cipher_impl.h index 50e73f6..410b1cf 100644 --- a/frameworks/cj/src/cipher_impl.h +++ b/frameworks/cj/include/cipher_impl.h @@ -32,7 +32,7 @@ public: HcfResult CipherUpdate(HcfBlob *input, HcfBlob *output); HcfResult CipherDoFinal(HcfBlob *input, HcfBlob *output); HcfResult SetCipherSpec(CipherSpecItem item, HcfBlob pSource); - HcfResult GetCipherSpecString(CipherSpecItem item, char **returnString); + HcfResult GetCipherSpecString(CipherSpecItem item, char *returnString); HcfResult GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array); const char *GetAlgorithm(int32_t* errCode); diff --git a/frameworks/cj/src/crypto_ffi.h b/frameworks/cj/include/crypto_ffi.h similarity index 31% rename from frameworks/cj/src/crypto_ffi.h rename to frameworks/cj/include/crypto_ffi.h index b167b2a..b885088 100644 --- a/frameworks/cj/src/crypto_ffi.h +++ b/frameworks/cj/include/crypto_ffi.h @@ -15,10 +15,33 @@ #ifndef CRYPTO_FFI_H #define CRYPTO_FFI_H -#include "cj_common_ffi.h" -#include "blob.h" -#include "cipher.h" -#include "algorithm_parameter.h" +#include "asy_key_generator_impl.h" +#include "asy_key_spec_generator_impl.h" +#include "cipher_impl.h" +#include "dh_key_util_impl.h" +#include "detailed_iv_params.h" +#include "detailed_gcm_params.h" +#include "detailed_ccm_params.h" +#include "detailed_dsa_key_params.h" +#include "detailed_ecc_key_params.h" +#include "detailed_rsa_key_params.h" +#include "detailed_alg_25519_key_params.h" +#include "detailed_dh_key_params.h" +#include "ecc_key_util_impl.h" +#include "kdf_impl.h" +#include "key_agreement_impl.h" +#include "key_pair_impl.h" +#include "mac_impl.h" +#include "md_impl.h" +#include "pri_key_impl.h" +#include "pub_key_impl.h" +#include "random_impl.h" +#include "securec.h" +#include "sign_impl.h" +#include "sm2_crypto_util_impl.h" +#include "sym_key_generator_impl.h" +#include "sym_key_impl.h" +#include "verify_impl.h" extern "C" { typedef struct { @@ -61,7 +84,7 @@ extern "C" { FFI_EXPORT int32_t FfiOHOSCipherUpdate(int64_t id, HcfBlob *input, HcfBlob *output); FFI_EXPORT int32_t FfiOHOSCipherDoFinal(int64_t id, HcfBlob *input, HcfBlob *output); FFI_EXPORT int32_t FfiOHOSSetCipherSpec(int64_t id, int32_t item, HcfBlob pSource); - FFI_EXPORT int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char **returnString); + FFI_EXPORT int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString); FFI_EXPORT int32_t FfiOHOSGetCipherSpecUint8Array(int64_t id, int32_t item, HcfBlob *returnUint8Array); FFI_EXPORT const char *FfiOHOSCipherGetAlgName(int64_t id, int32_t* errCode); @@ -70,10 +93,102 @@ extern "C" { FFI_EXPORT int32_t FfiOHOSCryptoMacInit(int64_t id, int64_t symKeyId); FFI_EXPORT int32_t FfiOHOSCryptoMacUpdate(int64_t id, HcfBlob *input); FFI_EXPORT HcfBlob FfiOHOSCryptoMacDoFinal(int64_t id, int32_t* errCode); - FFI_EXPORT uint32_t FfiOHOSGCryptoGetMacLength(int64_t id); + FFI_EXPORT uint32_t FfiOHOSCryptoGetMacLength(int64_t id); // sign FFI_EXPORT int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSSignInit(int64_t sid, int64_t pid); + FFI_EXPORT int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input); + FFI_EXPORT int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output); + FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue); + FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue); + FFI_EXPORT int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue); + FFI_EXPORT int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); + + // verify + FFI_EXPORT int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSVerifyInit(int64_t vid, int64_t pid); + FFI_EXPORT int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input); + FFI_EXPORT bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output); + FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue); + FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue); + FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue); + FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); + + // asykeygenerator + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode); + + // asykeyspecgenerator + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec( + HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode); + + // prikey + FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT int32_t FFiOHOSPriKeyClearMem(int64_t id); + FFI_EXPORT int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT const char *FfiOHOSPriKeyKeyGetFormat(int64_t id, int32_t* errCode); + + // pubkey + FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT const char *FfiOHOSPubKeyKeyGetFormat(int64_t id, int32_t* errCode); + + // keypair + FFI_EXPORT int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode); + + // kdf + FFI_EXPORT int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode); + FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params); + FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params); + + // ecc_key_util + FFI_EXPORT HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode); + FFI_EXPORT HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint( + char *curveName, HcfPoint point, char *format, int32_t *errCode); + + // keyagreement + FFI_EXPORT int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode); + + // dh_key_util + FFI_EXPORT HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec( + int32_t pLen, int32_t skLen, int32_t *errCode); + + // sm2_crypto_util + FFI_EXPORT HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode); + FFI_EXPORT Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode); } #endif diff --git a/frameworks/cj/include/dh_key_util_impl.h b/frameworks/cj/include/dh_key_util_impl.h new file mode 100644 index 0000000..1e94ea2 --- /dev/null +++ b/frameworks/cj/include/dh_key_util_impl.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef DH_KEY_UTIL_IMPL_H +#define DH_KEY_UTIL_IMPL_H + +#include "dh_key_util.h" +#include "blob.h" + +namespace OHOS { +namespace CryptoFramework { +class DHKeyUtilImpl { +public: + explicit DHKeyUtilImpl(); + ~DHKeyUtilImpl(); + static HcfDhCommParamsSpec *GenDHCommonParamsSpec(int32_t pLen, int32_t skLen, int32_t *errCode); +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/include/ecc_key_util_impl.h b/frameworks/cj/include/ecc_key_util_impl.h new file mode 100644 index 0000000..447e329 --- /dev/null +++ b/frameworks/cj/include/ecc_key_util_impl.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef ECC_KEY_UTIL_IMPL_H +#define ECC_KEY_UTIL_IMPL_H + +#include "ecc_key_util.h" +#include "blob.h" + +namespace OHOS { +namespace CryptoFramework { +class ECCKeyUtilImpl { +public: + explicit ECCKeyUtilImpl(); + ~ECCKeyUtilImpl(); + static HcfEccCommParamsSpec *GenECCCommonParamsSpec(char *algName, int32_t *errCode); + static HcfPoint ConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode); + static HcfBlob GetEncodedPoint(char *curveName, HcfPoint point, char *format, int32_t *errCode); +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/include/kdf_impl.h b/frameworks/cj/include/kdf_impl.h new file mode 100644 index 0000000..81b0458 --- /dev/null +++ b/frameworks/cj/include/kdf_impl.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef KDF_IMPL_H +#define KDF_IMPL_H + +#include "ffi_remote_data.h" +#include "blob.h" +#include "kdf.h" +#include "kdf_params.h" +#include "detailed_pbkdf2_params.h" +#include "detailed_hkdf_params.h" + +namespace OHOS { +namespace CryptoFramework { +class KdfImpl : public OHOS::FFI::FFIData { + DECL_TYPE(KdfImpl, OHOS::FFI::FFIData) +public: + explicit KdfImpl(HcfKdf *kdf); + ~KdfImpl(); + HcfKdf *GetKdf() const; + int32_t GenerateSecret(HcfKdfParamsSpec *paramsSpec); +private: + HcfKdf *kdf = nullptr; +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/include/key_agreement_impl.h b/frameworks/cj/include/key_agreement_impl.h new file mode 100644 index 0000000..2002d26 --- /dev/null +++ b/frameworks/cj/include/key_agreement_impl.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef KEY_AGREEMENT_IMPL_H +#define KEY_AGREEMENT_IMPL_H + +#include "ffi_remote_data.h" +#include "key_agreement.h" +#include "pri_key.h" +#include "pub_key.h" + +namespace OHOS { +namespace CryptoFramework { +class KeyAgreementImpl : public OHOS::FFI::FFIData { + DECL_TYPE(KeyAgreementImpl, OHOS::FFI::FFIData) +public: + explicit KeyAgreementImpl(HcfKeyAgreement *keyAgreement); + ~KeyAgreementImpl(); + HcfKeyAgreement *GetKeyAgreement(); + HcfBlob GenerateSecret(HcfPriKey *priKey, HcfPubKey *pubKey, int32_t *errCode); +private: + HcfKeyAgreement *keyAgreement_ = nullptr; +}; +} +} +#endif diff --git a/frameworks/cj/src/key_impl.h b/frameworks/cj/include/key_impl.h similarity index 95% rename from frameworks/cj/src/key_impl.h rename to frameworks/cj/include/key_impl.h index f579eb9..050f72f 100644 --- a/frameworks/cj/src/key_impl.h +++ b/frameworks/cj/include/key_impl.h @@ -18,6 +18,7 @@ #include "ffi_remote_data.h" #include "result.h" #include "key.h" +#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/include/key_pair_impl.h b/frameworks/cj/include/key_pair_impl.h new file mode 100644 index 0000000..570f83b --- /dev/null +++ b/frameworks/cj/include/key_pair_impl.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KEY_PAIR_IMPL_H +#define KEY_PAIR_IMPL_H + +#include +#include "key_pair.h" +#include "ffi_remote_data.h" + +namespace OHOS { +namespace CryptoFramework { +class KeyPairImpl : public OHOS::FFI::FFIData { +public: + explicit KeyPairImpl(HcfKeyPair *keyPair); + HcfKeyPair *GetHcfKeyPair(); + ~KeyPairImpl(); + +private: + HcfKeyPair *keyPair_ = nullptr; +}; +} // namespace CryptoFramework +} // namespace OHOS +#endif diff --git a/frameworks/cj/src/mac_impl.h b/frameworks/cj/include/mac_impl.h similarity index 93% rename from frameworks/cj/src/mac_impl.h rename to frameworks/cj/include/mac_impl.h index 0e9d3c1..dc04731 100644 --- a/frameworks/cj/src/mac_impl.h +++ b/frameworks/cj/include/mac_impl.h @@ -19,6 +19,8 @@ #include "ffi_remote_data.h" #include "mac.h" #include "blob.h" +#include "log.h" +#include "result.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/md_impl.h b/frameworks/cj/include/md_impl.h similarity index 93% rename from frameworks/cj/src/md_impl.h rename to frameworks/cj/include/md_impl.h index ab2c878..869d897 100644 --- a/frameworks/cj/src/md_impl.h +++ b/frameworks/cj/include/md_impl.h @@ -18,6 +18,8 @@ #include "ffi_remote_data.h" #include "md.h" #include "blob.h" +#include "log.h" +#include "result.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/include/pri_key_impl.h b/frameworks/cj/include/pri_key_impl.h new file mode 100644 index 0000000..65bb797 --- /dev/null +++ b/frameworks/cj/include/pri_key_impl.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PRI_KEY_IMPL_H +#define PRI_KEY_IMPL_H + +#include "key_impl.h" +#include "pri_key.h" +#include "ffi_remote_data.h" + +namespace OHOS { +namespace CryptoFramework { +class PriKeyImpl : public KeyImpl { + DECL_TYPE(PriKeyImpl, OHOS::FFI::FFIData) +public: + explicit PriKeyImpl(HcfPriKey *priKey); + ~PriKeyImpl() override; + HcfPriKey *GetPriKey(); +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/include/pub_key_impl.h b/frameworks/cj/include/pub_key_impl.h new file mode 100644 index 0000000..d9c39c9 --- /dev/null +++ b/frameworks/cj/include/pub_key_impl.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PUB_KEY_IMPL_H +#define PUB_KEY_IMPL_H + +#include "key_impl.h" +#include "pub_key.h" +#include "ffi_remote_data.h" + +namespace OHOS { +namespace CryptoFramework { +class PubKeyImpl : public KeyImpl { + DECL_TYPE(PubKeyImpl, OHOS::FFI::FFIData) +public: + explicit PubKeyImpl(HcfPubKey *pubKey); + ~PubKeyImpl() override; + HcfPubKey *GetPubKey(); +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/src/random_impl.h b/frameworks/cj/include/random_impl.h similarity index 93% rename from frameworks/cj/src/random_impl.h rename to frameworks/cj/include/random_impl.h index dc164b3..ff18d61 100644 --- a/frameworks/cj/src/random_impl.h +++ b/frameworks/cj/include/random_impl.h @@ -18,6 +18,8 @@ #include "ffi_remote_data.h" #include "rand.h" #include "blob.h" +#include "result.h" +#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/sign_impl.h b/frameworks/cj/include/sign_impl.h similarity index 68% rename from frameworks/cj/src/sign_impl.h rename to frameworks/cj/include/sign_impl.h index e59b0d7..a93baf9 100644 --- a/frameworks/cj/src/sign_impl.h +++ b/frameworks/cj/include/sign_impl.h @@ -19,6 +19,8 @@ #include "ffi_remote_data.h" #include "signature.h" #include "blob.h" +#include "result.h" +#include "pri_key.h" namespace OHOS { namespace CryptoFramework { @@ -27,6 +29,13 @@ class SignImpl : public OHOS::FFI::FFIData { public: explicit SignImpl(HcfSign *signObj); ~SignImpl(); + HcfResult Init(HcfPriKey *priKey); + HcfResult Update(HcfBlob *input); + HcfResult Sign(HcfBlob *input, HcfBlob *output); + HcfResult SetSignSpecByNum(int32_t itemValue); + HcfResult SetSignSpecByArr(HcfBlob itemValue); + HcfResult GetSignSpecString(SignSpecItem item, char *itemValue); + HcfResult GetSignSpecNum(SignSpecItem item, int32_t *itemValue); private: HcfSign *signObj_ = nullptr; diff --git a/frameworks/cj/include/sm2_crypto_util_impl.h b/frameworks/cj/include/sm2_crypto_util_impl.h new file mode 100644 index 0000000..1fec07f --- /dev/null +++ b/frameworks/cj/include/sm2_crypto_util_impl.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef SM2_CRYPTO_UTIL_IMPL_H +#define SM2_CRYPTO_UTIL_IMPL_H + +#include "sm2_crypto_util.h" + +namespace OHOS { +namespace CryptoFramework { +class Sm2CryptoUtilImpl { +public: + explicit Sm2CryptoUtilImpl(); + ~Sm2CryptoUtilImpl(); + static HcfBlob GenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode); + static Sm2CipherTextSpec *GetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode); +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/src/symkey_generator_impl.h b/frameworks/cj/include/sym_key_generator_impl.h similarity index 90% rename from frameworks/cj/src/symkey_generator_impl.h rename to frameworks/cj/include/sym_key_generator_impl.h index f57ec02..ccbeeb1 100644 --- a/frameworks/cj/src/symkey_generator_impl.h +++ b/frameworks/cj/include/sym_key_generator_impl.h @@ -12,13 +12,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef SYMKEY_GENERATOR_IMPL_H -#define SYMKEY_GENERATOR_IMPL_H +#ifndef SYM_KEY_GENERATOR_IMPL_H +#define SYM_KEY_GENERATOR_IMPL_H #include "ffi_remote_data.h" #include "sym_key.h" #include "result.h" #include "sym_key_generator.h" +#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/symkey_impl.h b/frameworks/cj/include/sym_key_impl.h similarity index 88% rename from frameworks/cj/src/symkey_impl.h rename to frameworks/cj/include/sym_key_impl.h index f125b01..81090b6 100644 --- a/frameworks/cj/src/symkey_impl.h +++ b/frameworks/cj/include/sym_key_impl.h @@ -12,12 +12,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef SYMKEY_IMPL_H -#define SYMKEY_IMPL_H +#ifndef SYM_KEY_IMPL_H +#define SYM_KEY_IMPL_H #include "ffi_remote_data.h" #include "sym_key.h" #include "key_impl.h" +#include "result.h" +#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/include/verify_impl.h b/frameworks/cj/include/verify_impl.h new file mode 100644 index 0000000..14b5b03 --- /dev/null +++ b/frameworks/cj/include/verify_impl.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef VERIFY_IMPL_H +#define VERIFY_IMPL_H + +#include "ffi_remote_data.h" +#include "pub_key.h" +#include "signature.h" + +namespace OHOS { +namespace CryptoFramework { +class VerifyImpl : public OHOS::FFI::FFIData { + DECL_TYPE(VerifyImpl, OHOS::FFI::FFIData) +public: + explicit VerifyImpl(HcfVerify *verify); + ~VerifyImpl(); + HcfVerify *GetVerify(); + HcfResult Init(HcfPubKey *pubKey); + HcfResult Update(HcfBlob *input); + bool Verify(HcfBlob *data, HcfBlob signatureData, int32_t *errCode); + HcfResult Recover(HcfBlob input, HcfBlob *output); + HcfResult SetVerifySpecByNum(int32_t itemValue); + HcfResult SetVerifySpecByArr(HcfBlob itemValue); + HcfResult GetVerifySpecString(SignSpecItem item, char *itemValue); + HcfResult GetVerifySpecNum(SignSpecItem item, int32_t *itemValue); +private: + HcfVerify *verify_ = nullptr; +}; +} +} +#endif \ No newline at end of file diff --git a/frameworks/cj/src/crypto_utils.cpp b/frameworks/cj/src/asy_key_generator_impl.cpp similarity index 61% rename from frameworks/cj/src/crypto_utils.cpp rename to frameworks/cj/src/asy_key_generator_impl.cpp index 9a6ca63..2e66639 100644 --- a/frameworks/cj/src/crypto_utils.cpp +++ b/frameworks/cj/src/asy_key_generator_impl.cpp @@ -1,28 +1,34 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "crypto_utils.h" - -char* Utils::MallocCString(const std::string& origin) -{ - if (origin.empty()) { - return nullptr; - } - auto len = origin.length() + 1; - char* res = static_cast(malloc(sizeof(char) * len)); - if (res == nullptr) { - return nullptr; - } - return std::char_traits::copy(res, origin.c_str(), len); +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "asy_key_generator_impl.h" + +namespace OHOS { +namespace CryptoFramework { +AsyKeyGeneratorImpl::AsyKeyGeneratorImpl(HcfAsyKeyGenerator *generator) +{ + this->generator_ = generator; +} + +AsyKeyGeneratorImpl::~AsyKeyGeneratorImpl() +{ + HcfObjDestroy(this->generator_); +} + +HcfAsyKeyGenerator *AsyKeyGeneratorImpl::GetAsyKeyGenerator() +{ + return this->generator_; +} +} } \ No newline at end of file diff --git a/frameworks/cj/src/asy_key_spec_generator_impl.cpp b/frameworks/cj/src/asy_key_spec_generator_impl.cpp new file mode 100644 index 0000000..d8bd7d8 --- /dev/null +++ b/frameworks/cj/src/asy_key_spec_generator_impl.cpp @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "asy_key_spec_generator_impl.h" + +namespace OHOS { +namespace CryptoFramework { +AsyKeyGeneratorBySpecImpl::AsyKeyGeneratorBySpecImpl(HcfAsyKeyGeneratorBySpec *generator) +{ + this->generator_ = generator; +} + +AsyKeyGeneratorBySpecImpl::~AsyKeyGeneratorBySpecImpl() +{ + HcfObjDestroy(this->generator_); +} + +HcfAsyKeyGeneratorBySpec *AsyKeyGeneratorBySpecImpl::GetAsyKeyGeneratorBySpec() +{ + return this->generator_; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/cipher_impl.cpp b/frameworks/cj/src/cipher_impl.cpp index 0ac1761..069a1c9 100644 --- a/frameworks/cj/src/cipher_impl.cpp +++ b/frameworks/cj/src/cipher_impl.cpp @@ -61,30 +61,27 @@ namespace OHOS { { if (cipher_ == nullptr) { LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; + return HCF_INVALID_PARAMS; } - HcfResult res = cipher_->setCipherSpecUint8Array(cipher_, item, pSource); - return res; + return cipher_->setCipherSpecUint8Array(cipher_, item, pSource); } - HcfResult CipherImpl::GetCipherSpecString(CipherSpecItem item, char **returnString) + HcfResult CipherImpl::GetCipherSpecString(CipherSpecItem item, char *returnString) { if (cipher_ == nullptr) { LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; + return HCF_INVALID_PARAMS; } - HcfResult res = cipher_->getCipherSpecString(cipher_, item, returnString); - return res; + return cipher_->getCipherSpecString(cipher_, item, &returnString); } HcfResult CipherImpl::GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array) { if (cipher_ == nullptr) { LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; + return HCF_INVALID_PARAMS; } - HcfResult res = cipher_->getCipherSpecUint8Array(cipher_, item, returnUint8Array); - return res; + return cipher_->getCipherSpecUint8Array(cipher_, item, returnUint8Array); } const char *CipherImpl::GetAlgorithm(int32_t* errCode) diff --git a/frameworks/cj/src/crypto_ffi.cpp b/frameworks/cj/src/crypto_ffi.cpp index ca2e02a..18424ae 100644 --- a/frameworks/cj/src/crypto_ffi.cpp +++ b/frameworks/cj/src/crypto_ffi.cpp @@ -13,21 +13,12 @@ * limitations under the License. */ #include "crypto_ffi.h" -#include "random_impl.h" -#include "mac_impl.h" -#include "md_impl.h" -#include "log.h" -#include "sign_impl.h" -#include "symkey_generator_impl.h" -#include "symkey_impl.h" -#include "cipher_impl.h" -#include "detailed_iv_params.h" -#include "detailed_gcm_params.h" -#include "detailed_ccm_params.h" -#include "securec.h" #define MAX_MEMORY_SIZE (5 * 1024 * 1024) +const std::string PBKDF2_ALG_NAME = "PBKDF2"; +const std::string HKDF_ALG_NAME = "HKDF"; + using namespace OHOS::FFI; namespace OHOS { @@ -564,7 +555,7 @@ namespace OHOS { return res; } - int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char **returnString) + int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString) { LOGD("[Cipher] GetCipherSpecString start"); auto instance = FFIData::GetData(id); @@ -687,7 +678,7 @@ namespace OHOS { return blob; } - uint32_t FfiOHOSGCryptoGetMacLength(int64_t id) + uint32_t FfiOHOSCryptoGetMacLength(int64_t id) { LOGD("[Mac] FfiOHOSGCryptoGetMacLength start"); auto instance = FFIData::GetData(id); @@ -704,24 +695,1126 @@ namespace OHOS { //--------------------- sign int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode) { - LOGD("[Sign] CreateSign start"); + LOGD("[Sign] FFiOHOSCryptoSignConstructor start"); HcfSign *signObj = nullptr; HcfResult res = HcfSignCreate(algName, &signObj); *errCode = static_cast(res); if (res != HCF_SUCCESS) { - LOGE("create c signObj failed."); + LOGE("[Sign] FFiOHOSCryptoSignConstructor create c signObj failed."); return 0; } auto native = FFIData::Create(signObj); if (native == nullptr) { - LOGE("[Sign] CreateSign failed"); + LOGE("[Sign] FFiOHOSCryptoSignConstructor create failed"); HcfObjDestroy(signObj); *errCode = HCF_ERR_MALLOC; return 0; } - LOGD("[Sign] CreateSign success"); + LOGD("[Sign] FFiOHOSCryptoSignConstructor success"); + return native->GetID(); + } + + int32_t FFiOHOSSignInit(int64_t sid, int64_t pid) + { + LOGD("[Sign] FFiOHOSSignInit start"); + auto sign = FFIData::GetData(sid); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + auto priKeyImpl = FFIData::GetData(pid); + if (priKeyImpl == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get priKeyImpl obj."); + return HCF_INVALID_PARAMS; + } + HcfPriKey *priKey = priKeyImpl->GetPriKey(); + if (priKey == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get priKey obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignInit success"); + return sign->Init(priKey); + } + + int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input) + { + LOGD("[Sign] FFiOHOSSignUpdate start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignUpdate failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignUpdate success"); + return sign->Update(&input); + } + + int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output) + { + LOGD("[Sign] FFiOHOSSignSign start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSign failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSign success"); + return sign->Sign(input, output); + } + + int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue) + { + LOGD("[Sign] FFiOHOSSignSetSignSpecByNum start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSetSignSpecByNum failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSetSignSpecByNum success"); + return sign->SetSignSpecByNum(itemValue); + } + + int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue) + { + LOGD("[Sign] FFiOHOSSignSetSignSpecByArr start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSetSignSpecByArr failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSetSignSpecByArr success"); + return sign->SetSignSpecByArr(itemValue); + } + + int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue) + { + LOGD("[Sign] FFiOHOSSignGetSignSpecString start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignGetSignSpecString failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignGetSignSpecString success"); + return sign->GetSignSpecString(item, itemValue); + } + + int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) + { + LOGD("[Sign] FFiOHOSSignGetSignSpecNum start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignGetSignSpecNum failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignGetSignSpecNum success"); + return sign->GetSignSpecNum(item, itemValue); + } + + //--------------------- verify + int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode) + { + LOGD("[Verify]FFiOHOSVerifyConstructor start"); + HcfVerify *verify = nullptr; + HcfResult res = HcfVerifyCreate(algName, &verify); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("[Verify] FFiOHOSVerifyConstructor create c verifyObj failed."); + return 0; + } + auto native = FFIData::Create(verify); + if (native == nullptr) { + LOGE("[Verify] FFiOHOSVerifyConstructor create failed"); + HcfObjDestroy(verify); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Verify] FFiOHOSVerifyConstructor success"); return native->GetID(); } + + int32_t FFiOHOSVerifyInit(int64_t sid, int64_t pid) + { + LOGD("[Verify] FFiOHOSVerifyInit start"); + auto verify = FFIData::GetData(sid); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + auto pubKeyImpl = FFIData::GetData(pid); + if (pubKeyImpl == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get priKeyImpl obj."); + return HCF_INVALID_PARAMS; + } + HcfPubKey *pubKey = pubKeyImpl->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get priKey obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyInit success"); + return verify->Init(pubKey); + } + + int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input) + { + LOGD("[Verify] FFiOHOSVerifyUpdate start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyUpdate failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyUpdate success"); + return verify->Update(&input); + } + + bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode) + { + LOGD("[Verify] FFiOHOSVerifyVerify start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyVerify success"); + return verify->Verify(data, signatureData, errCode); + } + + int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output) + { + LOGD("[Verify] FFiOHOSVerifyRecover start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyRecover success"); + return verify->Recover(input, output); + } + + + int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue) + { + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifySetVerifySpecByNum failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum success"); + return verify->SetVerifySpecByNum(itemValue); + } + + int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue) + { + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifySetVerifySpecByArr failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr success"); + return verify->SetVerifySpecByArr(itemValue); + } + + int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue) + { + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyGetVerifySpecString failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString success"); + return verify->GetVerifySpecString(item, itemValue); + } + + int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) + { + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyGetVerifySpecNum failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum success"); + return verify->GetVerifySpecNum(item, itemValue); + } + + //--------------------- asykeygenerator + int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor start"); + HcfAsyKeyGenerator *generator = nullptr; + *errCode = HcfAsyKeyGeneratorCreate(algName, &generator); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c generator fail."); + return 0; + } + auto instance = FFIData::Create(generator); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(generator); + LOGE("new asy key generator failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor end"); + return instance->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->generateKeyPair(generator, params, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("generate key pair fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->convertKey(generator, params, pubKey, priKey, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("convert key fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->convertPemKey(generator, params, pubKey, priKey, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGE("ConvertPemKey fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey end"); + return keyPair->GetID(); + } + + //--------------------- asykeyspecgenerator + int64_t AsyKeyGeneratorBySpecConstructor(HcfAsyKeyParamsSpec *asyKeySpec, int32_t *errCode) + { + HcfAsyKeyGeneratorBySpec *generator = nullptr; + *errCode = HcfAsyKeyGeneratorBySpecCreate(asyKeySpec, &generator); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create C generator by sepc fail."); + return 0; + } + auto instance = FFIData::Create(generator); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(generator); + LOGE("new asy key generator by spec failed!"); + return 0; + } + return instance->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec(HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpecc end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + *errCode = generator->generateKeyPair(generator, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("generate key pair fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfPriKey *returnPriKey = nullptr; + *errCode = generator->generatePriKey(generator, &returnPriKey); + if (*errCode != HCF_SUCCESS) { + LOGD("generate PriKey fail."); + return 0; + } + auto priKey = FFIData::Create(returnPriKey); + if (priKey == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnPriKey); + LOGE("new pri key failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey end"); + return priKey->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfPubKey *returnPubKey = nullptr; + *errCode = generator->generatePubKey(generator, &returnPubKey); + if (*errCode != HCF_SUCCESS) { + LOGD("generate PubKey fail."); + return 0; + } + auto pubKey = FFIData::Create(returnPubKey); + if (pubKey == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnPubKey); + LOGE("new pub key failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey end"); + return pubKey->GetID(); + } + + //--------------------- prikey + HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncoded start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->base.getEncoded(&priKey->base, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncoded end"); + return ret; + } + + HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->getEncodedDer(priKey, format, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer end"); + return ret; + } + + char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem start"); + char *ret = nullptr; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->base.getEncodedPem(&priKey->base, format, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem end"); + return ret; + } + + int32_t FFiOHOSPriKeyClearMem(int64_t id) + { + LOGD("[PriKey] FFiOHOSPriKeyClearMem start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to unwrap private key obj!"); + return HCF_INVALID_PARAMS; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to get private key obj!"); + return HCF_INVALID_PARAMS; + } + priKey->clearMem(priKey); + LOGD("[PriKey] FFiOHOSPriKeyClearMem end"); + return HCF_SUCCESS; + } + + int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + int ret = 0; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecInt(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + char *ret = nullptr; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecString(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + HcfBigInteger ret = { 0 }; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecBigInteger(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + const char *FfiOHOSPriKeyGetFormat(int64_t id, int32_t* errCode) + { + LOGD("[PriKey] GetFormat start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetFormat(errCode); + LOGD("[PriKey] GetFormat success"); + return res; + } + + //--------------------- pubkey + HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncoded start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->base.getEncoded(&pubKey->base, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncoded end"); + return ret; + } + + HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->getEncodedDer(pubKey, format, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer end"); + return ret; + } + + char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem start"); + char *ret = nullptr; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->base.getEncodedPem(&pubKey->base, format, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem end"); + return ret; + } + + int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + int ret = 0; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecInt(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + char *ret = nullptr; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecString(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + HcfBigInteger ret = { 0 }; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecBigInteger(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + const char *FfiOHOSPubKeyGetFormat(int64_t id, int32_t* errCode) + { + LOGD("[PubKey] GetFormat start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetFormat(errCode); + LOGD("[PubKey] GetFormat success"); + return res; + } + + // ------------------------------------keypair + int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode) + { + LOGD("[KeyPair] FFiOHOSKeyPairPubKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfKeyPair *keyPair = instance->GetHcfKeyPair(); + if (keyPair == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get keyPair fail."); + return 0; + } + HcfPubKey *pubKey = keyPair->pubKey; + if (pubKey == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get pubKey fail."); + return 0; + } + auto pub = FFIData::Create(pubKey); + if (pub == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("new pub key failed"); + return 0; + } + LOGD("[KeyPair] FFiOHOSKeyPairPubKey end"); + return pub->GetID(); + } + + int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode) + { + LOGD("[KeyPair] FFiOHOSKeyPairPriKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfKeyPair *keyPair = instance->GetHcfKeyPair(); + if (keyPair == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get keyPair fail."); + return 0; + } + HcfPriKey *priKey = keyPair->priKey; + if (priKey == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get priKey fail."); + return 0; + } + auto pri = FFIData::Create(priKey); + if (pri == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("new pri key failed"); + return 0; + } + LOGD("[KeyPair] FFiOHOSKeyPairPriKey end"); + return pri->GetID(); + } + + // ------------------------------------kdf + int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode) + { + LOGD("[Kdf] FFiOHOSKdfConstructor start"); + HcfKdf *kdf = nullptr; + *errCode = HcfKdfCreate(algName, &kdf); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c kdf fail."); + return 0; + } + auto instance = FFIData::Create(kdf); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(kdf); + LOGE("new kdf failed!"); + return 0; + } + LOGD("[Kdf] FFiOHOSKdfConstructor end"); + return instance->GetID(); + } + + int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params) + { + LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FiOHOSKdfGenerateSecretByPB failed to get kdf impl obj!"); + return HCF_INVALID_PARAMS; + } + HcfKdfParamsSpec *tmp = reinterpret_cast(params); + LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB end"); + return instance->GenerateSecret(tmp); + } + + int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params) + { + LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] F FFiOHOSKdfGenerateSecretByH failed to get kdf impl obj!"); + return HCF_INVALID_PARAMS; + } + HcfKdfParamsSpec *tmp = reinterpret_cast(params); + LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH end"); + return instance->GenerateSecret(tmp); + } + + // --------------------------ecc_key_util + HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode) + { + return ECCKeyUtilImpl::GenECCCommonParamsSpec(curveName, errCode); + } + + HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode) + { + return ECCKeyUtilImpl::ConvertPoint(curveName, encodedPoint, errCode); + } + + HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint(char *curveName, HcfPoint point, char *format, int32_t *errCode) + { + return ECCKeyUtilImpl::GetEncodedPoint(curveName, point, format, errCode); + } + + // ---------------------------keyagreement + int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode) + { + LOGD("[KeyAgreement] FFiOHOSKdfConstructor start"); + HcfKeyAgreement *keyAgreement = nullptr; + *errCode = HcfKeyAgreementCreate(algName, &keyAgreement); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c keyAgreement fail."); + return 0; + } + auto instance = FFIData::Create(keyAgreement); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(keyAgreement); + LOGE("new key agreement failed!"); + return 0; + } + LOGD("[KeyAgreement] FFiOHOSKdfConstructor end"); + return instance->GetID(); + } + + HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode) + { + LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret start"); + auto instance = FFIData::GetData(id); + HcfBlob blob = { 0 }; + if (!instance) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get key agreement obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + auto priKey = FFIData::GetData(priId); + if (!priKey) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + auto pubKey = FFIData::GetData(pubId); + if (!pubKey) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret end"); + return instance->GenerateSecret(priKey->GetPriKey(), pubKey->GetPubKey(), errCode); + } + + // dh_key_util + HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec(int32_t pLen, int32_t skLen, int32_t *errCode) + { + return DHKeyUtilImpl::GenDHCommonParamsSpec(pLen, skLen, errCode); + } + + // sm2_crypto_util + HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode) + { + return Sm2CryptoUtilImpl::GenCipherTextBySpec(spec, mode, errCode); + } + + Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode) + { + return Sm2CryptoUtilImpl::GetCipherTextSpec(input, mode, errCode); + } } } // namespace CryptoFramework } // namespace OHOS \ No newline at end of file diff --git a/frameworks/cj/src/dh_key_util_impl.cpp b/frameworks/cj/src/dh_key_util_impl.cpp new file mode 100644 index 0000000..f4f5f1c --- /dev/null +++ b/frameworks/cj/src/dh_key_util_impl.cpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dh_key_util_impl.h" + +namespace OHOS { +namespace CryptoFramework { +DHKeyUtilImpl::DHKeyUtilImpl() {} + +DHKeyUtilImpl::~DHKeyUtilImpl() {} + +HcfDhCommParamsSpec *DHKeyUtilImpl::GenDHCommonParamsSpec(int32_t pLen, int32_t skLen, int32_t *errCode) +{ + HcfDhCommParamsSpec *dhCommParamsSpec = nullptr; + *errCode = HcfDhKeyUtilCreate(pLen, skLen, &dhCommParamsSpec); + return dhCommParamsSpec; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/ecc_key_util_impl.cpp b/frameworks/cj/src/ecc_key_util_impl.cpp new file mode 100644 index 0000000..9e8a51d --- /dev/null +++ b/frameworks/cj/src/ecc_key_util_impl.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ecc_key_util_impl.h" + +namespace OHOS { +namespace CryptoFramework { +ECCKeyUtilImpl::ECCKeyUtilImpl() {} + +ECCKeyUtilImpl::~ECCKeyUtilImpl() {} + +HcfEccCommParamsSpec *ECCKeyUtilImpl::GenECCCommonParamsSpec(char *algName, int32_t *errCode) +{ + HcfEccCommParamsSpec *eccCommParamsSpec = nullptr; + *errCode = HcfEccKeyUtilCreate(algName, &eccCommParamsSpec); + return eccCommParamsSpec; +} + +HcfPoint ECCKeyUtilImpl::ConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode) +{ + HcfPoint point; + *errCode = HcfConvertPoint(curveName, &encodedPoint, &point); + return point; +} + +HcfBlob ECCKeyUtilImpl::GetEncodedPoint(char *curveName, HcfPoint point, char *format, int32_t *errCode) +{ + HcfBlob returnBlob; + *errCode = HcfGetEncodedPoint(curveName, &point, format, &returnBlob); + return returnBlob; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/kdf_impl.cpp b/frameworks/cj/src/kdf_impl.cpp new file mode 100644 index 0000000..5fffde9 --- /dev/null +++ b/frameworks/cj/src/kdf_impl.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "kdf_impl.h" + +namespace OHOS { +namespace CryptoFramework { +KdfImpl::KdfImpl(HcfKdf *kdfObj) +{ + this->kdf = kdfObj; +} + +KdfImpl::~KdfImpl() +{ + HcfObjDestroy(this->kdf); + this->kdf = nullptr; +} + +HcfKdf *KdfImpl::GetKdf() const +{ + return this->kdf; +} + +int32_t KdfImpl::GenerateSecret(HcfKdfParamsSpec *paramsSpec) +{ + if (this->kdf == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->kdf->generateSecret(kdf, paramsSpec); +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/key_agreement_impl.cpp b/frameworks/cj/src/key_agreement_impl.cpp new file mode 100644 index 0000000..e92bf40 --- /dev/null +++ b/frameworks/cj/src/key_agreement_impl.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "key_agreement_impl.h" + +namespace OHOS { +namespace CryptoFramework { +KeyAgreementImpl::KeyAgreementImpl(HcfKeyAgreement *keyAgreement) +{ + this->keyAgreement_ = keyAgreement; +} + +KeyAgreementImpl::~KeyAgreementImpl() +{ + HcfObjDestroy(this->keyAgreement_); + this->keyAgreement_ = nullptr; +} + +HcfKeyAgreement *KeyAgreementImpl::GetKeyAgreement() +{ + return this->keyAgreement_; +} + +HcfBlob KeyAgreementImpl::GenerateSecret(HcfPriKey *priKey, HcfPubKey *pubKey, int32_t *errCode) +{ + HcfBlob returnSecret = { .data = nullptr, .len = 0 }; + if (this->keyAgreement_ == nullptr || priKey == nullptr || pubKey == nullptr) { + *errCode = HCF_INVALID_PARAMS; + return returnSecret; + } + *errCode = this->keyAgreement_->generateSecret(keyAgreement_, priKey, pubKey, &returnSecret); + return returnSecret; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/key_impl.cpp b/frameworks/cj/src/key_impl.cpp index 98a191a..20a8078 100644 --- a/frameworks/cj/src/key_impl.cpp +++ b/frameworks/cj/src/key_impl.cpp @@ -13,8 +13,6 @@ * limitations under the License. */ #include "key_impl.h" -#include "result.h" -#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/key_pair_impl.cpp b/frameworks/cj/src/key_pair_impl.cpp new file mode 100644 index 0000000..f06c2a1 --- /dev/null +++ b/frameworks/cj/src/key_pair_impl.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "key_pair_impl.h" + +namespace OHOS { +namespace CryptoFramework { +KeyPairImpl::KeyPairImpl(HcfKeyPair *keyPair) +{ + this->keyPair_ = keyPair; +} + +KeyPairImpl::~KeyPairImpl() +{ + HcfObjDestroy(this->keyPair_); + this->keyPair_ = nullptr; +} + +HcfKeyPair *KeyPairImpl::GetHcfKeyPair() +{ + return this->keyPair_; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/mac_impl.cpp b/frameworks/cj/src/mac_impl.cpp index 03e08b3..bcc04ef 100644 --- a/frameworks/cj/src/mac_impl.cpp +++ b/frameworks/cj/src/mac_impl.cpp @@ -14,8 +14,6 @@ */ #include "mac_impl.h" -#include "log.h" -#include "result.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/md_impl.cpp b/frameworks/cj/src/md_impl.cpp index 3a78325..b823373 100644 --- a/frameworks/cj/src/md_impl.cpp +++ b/frameworks/cj/src/md_impl.cpp @@ -13,8 +13,6 @@ * limitations under the License. */ #include "md_impl.h" -#include "log.h" -#include "result.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/crypto_utils.h b/frameworks/cj/src/pri_key_impl.cpp similarity index 67% rename from frameworks/cj/src/crypto_utils.h rename to frameworks/cj/src/pri_key_impl.cpp index ac677b1..7dda028 100644 --- a/frameworks/cj/src/crypto_utils.h +++ b/frameworks/cj/src/pri_key_impl.cpp @@ -12,18 +12,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include "pri_key_impl.h" -#ifndef OHOS_CRYPTO_UTILS_H -#define OHOS_CRYPTO_UTILS_H +namespace OHOS { +namespace CryptoFramework { +PriKeyImpl::PriKeyImpl(HcfPriKey *priKey) : KeyImpl(reinterpret_cast(priKey)) {} -#include -#include -#include +PriKeyImpl::~PriKeyImpl() {} -#define FFI_EXPORT __attribute__((visibility("default"))) - -class FFI_EXPORT Utils { -public: - static char* MallocCString(const std::string& origin); -}; -#endif +HcfPriKey *PriKeyImpl::GetPriKey() +{ + return reinterpret_cast(KeyImpl::GetHcfKey()); +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/pub_key_impl.cpp b/frameworks/cj/src/pub_key_impl.cpp new file mode 100644 index 0000000..5c8e2a1 --- /dev/null +++ b/frameworks/cj/src/pub_key_impl.cpp @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "pub_key_impl.h" + +namespace OHOS { +namespace CryptoFramework { +PubKeyImpl::PubKeyImpl(HcfPubKey *pubKey) : KeyImpl(reinterpret_cast(pubKey)) {} + +PubKeyImpl::~PubKeyImpl() {} + +HcfPubKey *PubKeyImpl::GetPubKey() +{ + return reinterpret_cast(KeyImpl::GetHcfKey()); +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/random_impl.cpp b/frameworks/cj/src/random_impl.cpp index 9ed0e41..03bac70 100644 --- a/frameworks/cj/src/random_impl.cpp +++ b/frameworks/cj/src/random_impl.cpp @@ -13,8 +13,6 @@ * limitations under the License. */ #include "random_impl.h" -#include "result.h" -#include "log.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/sign_impl.cpp b/frameworks/cj/src/sign_impl.cpp index 3d417d8..89a4fbd 100644 --- a/frameworks/cj/src/sign_impl.cpp +++ b/frameworks/cj/src/sign_impl.cpp @@ -14,19 +14,73 @@ */ #include "sign_impl.h" -#include "log.h" -#include "result.h" namespace OHOS { - namespace CryptoFramework { - SignImpl::SignImpl(HcfSign *signObj) - { - signObj_ = signObj; - } - - SignImpl::~SignImpl() - { - HcfObjDestroy(this->signObj_); - } +namespace CryptoFramework { +SignImpl::SignImpl(HcfSign *signObj) +{ + signObj_ = signObj; +} + +SignImpl::~SignImpl() +{ + HcfObjDestroy(this->signObj_); +} + +HcfResult SignImpl::Init(HcfPriKey *priKey) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->init(signObj_, nullptr, priKey); +} + +HcfResult SignImpl::Update(HcfBlob *input) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->update(signObj_, input); +} + +HcfResult SignImpl::Sign(HcfBlob *input, HcfBlob *output) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->sign(signObj_, input, output); +} + +HcfResult SignImpl::SetSignSpecByNum(int32_t itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->setSignSpecInt(signObj_, PSS_SALT_LEN_INT, itemValue); +} + +HcfResult SignImpl::SetSignSpecByArr(HcfBlob itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->setSignSpecUint8Array(signObj_, SM2_USER_ID_UINT8ARR, itemValue); +} + +HcfResult SignImpl::GetSignSpecString(SignSpecItem item, char *itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->getSignSpecString(signObj_, item, &itemValue); +} + +HcfResult SignImpl::GetSignSpecNum(SignSpecItem item, int32_t *itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; } + return this->signObj_->getSignSpecInt(signObj_, item, itemValue); +} +} } \ No newline at end of file diff --git a/frameworks/cj/src/sm2_crypto_util_impl.cpp b/frameworks/cj/src/sm2_crypto_util_impl.cpp new file mode 100644 index 0000000..cabf217 --- /dev/null +++ b/frameworks/cj/src/sm2_crypto_util_impl.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sm2_crypto_util_impl.h" + +namespace OHOS { +namespace CryptoFramework { +Sm2CryptoUtilImpl::Sm2CryptoUtilImpl() {} + +Sm2CryptoUtilImpl::~Sm2CryptoUtilImpl() {} + +HcfBlob Sm2CryptoUtilImpl::GenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode) +{ + HcfBlob output = { 0 }; + *errCode = HcfGenCipherTextBySpec(&spec, mode, &output); + return output; +} + +Sm2CipherTextSpec *Sm2CryptoUtilImpl::GetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode) +{ + Sm2CipherTextSpec *returnSpec = nullptr; + *errCode = HcfGetCipherTextSpec(&input, mode, &returnSpec); + return returnSpec; +} +} +} \ No newline at end of file diff --git a/frameworks/cj/src/symkey_generator_impl.cpp b/frameworks/cj/src/sym_key_generator_impl.cpp similarity index 94% rename from frameworks/cj/src/symkey_generator_impl.cpp rename to frameworks/cj/src/sym_key_generator_impl.cpp index c5dd9ce..9d13539 100644 --- a/frameworks/cj/src/symkey_generator_impl.cpp +++ b/frameworks/cj/src/sym_key_generator_impl.cpp @@ -12,8 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "symkey_generator_impl.h" -#include "log.h" +#include "sym_key_generator_impl.h" namespace OHOS { namespace CryptoFramework { @@ -39,7 +38,6 @@ namespace OHOS { return algo; } - HcfResult SymKeyGeneratorImpl::GenerateSymKey(HcfSymKey **symKey) { if (generator_ == nullptr) { diff --git a/frameworks/cj/src/symkey_impl.cpp b/frameworks/cj/src/sym_key_impl.cpp similarity index 92% rename from frameworks/cj/src/symkey_impl.cpp rename to frameworks/cj/src/sym_key_impl.cpp index 13836a0..8990b92 100644 --- a/frameworks/cj/src/symkey_impl.cpp +++ b/frameworks/cj/src/sym_key_impl.cpp @@ -12,9 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "symkey_impl.h" -#include "result.h" -#include "log.h" +#include "sym_key_impl.h" namespace OHOS { namespace CryptoFramework { diff --git a/frameworks/cj/src/verify_impl.cpp b/frameworks/cj/src/verify_impl.cpp new file mode 100644 index 0000000..1ddfba8 --- /dev/null +++ b/frameworks/cj/src/verify_impl.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "verify_impl.h" + +namespace OHOS { +namespace CryptoFramework { +VerifyImpl::VerifyImpl(HcfVerify *verify) +{ + this->verify_ = verify; +} + +VerifyImpl::~VerifyImpl() +{ + HcfObjDestroy(this->verify_); +} + +HcfResult VerifyImpl::Init(HcfPubKey *pubKey) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->init(verify_, nullptr, pubKey); +} + +HcfResult VerifyImpl::Update(HcfBlob *input) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->update(verify_, input); +} + +bool VerifyImpl::Verify(HcfBlob *data, HcfBlob signatureData, int32_t *errCode) +{ + if (this->verify_ == nullptr) { + *errCode = HCF_INVALID_PARAMS; + return false; + } + *errCode = HCF_SUCCESS; + return this->verify_->verify(verify_, data, &signatureData); +} + +HcfResult VerifyImpl::Recover(HcfBlob input, HcfBlob *output) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->recover(verify_, &input, output); +} + +HcfResult VerifyImpl::SetVerifySpecByNum(int32_t itemValue) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->setVerifySpecInt(verify_, PSS_SALT_LEN_INT, itemValue); +} + +HcfResult VerifyImpl::SetVerifySpecByArr(HcfBlob itemValue) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->setVerifySpecUint8Array(verify_, SM2_USER_ID_UINT8ARR, itemValue); +} + +HcfResult VerifyImpl::GetVerifySpecString(SignSpecItem item, char *itemValue) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->getVerifySpecString(verify_, item, &itemValue); +} + +HcfResult VerifyImpl::GetVerifySpecNum(SignSpecItem item, int32_t *itemValue) +{ + if (this->verify_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->verify_->getVerifySpecInt(verify_, item, itemValue); +} +} +} \ No newline at end of file -- Gitee From 447e424746dfaf0d42cbbb5fdea8bf1181257f9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Tue, 13 Aug 2024 11:34:45 +0800 Subject: [PATCH 04/32] =?UTF-8?q?cppcheck=E5=91=8A=E8=AD=A6=E6=B8=85?= =?UTF-8?q?=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 王静 --- test/unittest/src/native/native_asym_key_test.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/test/unittest/src/native/native_asym_key_test.cpp b/test/unittest/src/native/native_asym_key_test.cpp index cf4c157..16e8351 100644 --- a/test/unittest/src/native/native_asym_key_test.cpp +++ b/test/unittest/src/native/native_asym_key_test.cpp @@ -64,7 +64,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest001, TestSize.Level0) const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(generator); ASSERT_NE(algoName, nullptr); - + OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx); Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 }; @@ -109,7 +109,6 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest002, TestSize.Level0) cmpRes = strcmp(reinterpret_cast(retBlobX509.data), reinterpret_cast(pubKeyX509Str.data)); EXPECT_EQ(cmpRes, CRYPTO_SUCCESS); - OH_Crypto_FreeDataBlob(&retBlob); OH_Crypto_FreeDataBlob(&retBlobX509); OH_CryptoKeyPair_Destroy(dupKeyPair); @@ -124,7 +123,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest003, TestSize.Level0) EXPECT_EQ(ret, CRYPTO_SUCCESS); ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx); EXPECT_EQ(ret, CRYPTO_SUCCESS); - + OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx); Crypto_DataBlob dataBlobE = { .data = nullptr, .len = 0 }; ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, &dataBlobE); @@ -165,7 +164,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest004, TestSize.Level0) OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair); ASSERT_EQ(ret, CRYPTO_SUCCESS); Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 }; - + ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_RSA_N_DATABLOB, &dataBlob); ASSERT_EQ(ret, CRYPTO_SUCCESS); ASSERT_NE(dataBlob.data, nullptr); @@ -206,7 +205,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest005, TestSize.Level0) OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair); ASSERT_EQ(ret, CRYPTO_SUCCESS); Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 }; - + ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_ED25519_PK_DATABLOB, &dataBlob); ASSERT_EQ(ret, CRYPTO_SUCCESS); ASSERT_NE(dataBlob.data, nullptr); -- Gitee From 1640a51e4a9e10bc8fb8c6e6af4534e279661b30 Mon Sep 17 00:00:00 2001 From: lanming Date: Wed, 14 Aug 2024 19:30:57 +0800 Subject: [PATCH 05/32] =?UTF-8?q?=E5=8A=A0=E8=A7=A3=E5=AF=86=E7=AE=97?= =?UTF-8?q?=E6=B3=95=E5=BA=93=E6=A1=86=E6=9E=B6=E6=96=B0=E5=A2=9Esyscap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lanming --- bundle.json | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/bundle.json b/bundle.json index 0ea0526..3fe7bf3 100644 --- a/bundle.json +++ b/bundle.json @@ -14,7 +14,19 @@ "component": { "name": "crypto_framework", "subsystem": "security", - "syscap": [ "SystemCapability.Security.CryptoFramework" ], + "syscap": [ + "SystemCapability.Security.CryptoFramework", + "SystemCapability.Security.CryptoFramework.Key", + "SystemCapability.Security.CryptoFramework.Key.SymKey", + "SystemCapability.Security.CryptoFramework.Key.AsymKey", + "SystemCapability.Security.CryptoFramework.Signature", + "SystemCapability.Security.CryptoFramework.Cipher", + "SystemCapability.Security.CryptoFramework.KeyAgreement", + "SystemCapability.Security.CryptoFramework.MessageDigest", + "SystemCapability.Security.CryptoFramework.Mac", + "SystemCapability.Security.CryptoFramework.Kdf", + "SystemCapability.Security.CryptoFramework.Rand" + ], "features": [ "crypto_framework_enabled" ], "adapted_system_type": [ "standard" -- Gitee From 09b8f3c39b8ed113a3c2a871f8dc62be1509c11e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=90=8C=E8=90=8C=E8=90=8C=E6=96=B0?= Date: Thu, 15 Aug 2024 11:09:29 +0800 Subject: [PATCH 06/32] clean codecheck MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 萌萌萌新 --- frameworks/cj/src/crypto_ffi.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/frameworks/cj/src/crypto_ffi.cpp b/frameworks/cj/src/crypto_ffi.cpp index 18424ae..cf19382 100644 --- a/frameworks/cj/src/crypto_ffi.cpp +++ b/frameworks/cj/src/crypto_ffi.cpp @@ -16,9 +16,6 @@ #define MAX_MEMORY_SIZE (5 * 1024 * 1024) -const std::string PBKDF2_ALG_NAME = "PBKDF2"; -const std::string HKDF_ALG_NAME = "HKDF"; - using namespace OHOS::FFI; namespace OHOS { -- Gitee From 6bd793baf1b39460a2e782ad6700a5eef413c958 Mon Sep 17 00:00:00 2001 From: hhhFun Date: Sat, 17 Aug 2024 12:48:55 +0000 Subject: [PATCH 07/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9codecheck?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- .../src/crypto_asy_key_convert_pem_test.cpp | 224 +++++++++--------- 1 file changed, 112 insertions(+), 112 deletions(-) diff --git a/test/unittest/src/crypto_asy_key_convert_pem_test.cpp b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp index 86c7ef8..2462368 100644 --- a/test/unittest/src/crypto_asy_key_convert_pem_test.cpp +++ b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp @@ -678,147 +678,147 @@ static string g_testDsa3072PubKey = "-----BEGIN PUBLIC KEY-----\n" "J5CGPcuzhta1Ju41XMtRHHigBtL62r4=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP160r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP160r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MGQCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEBBEkwRwIBAQQUASO/LfZI7/oU61jD\n" "jI3iN3daCsKhLAMqAAR9QXIl11ePlAzVlwjLUnkKjxX6LBAU4Q0sOo1eeDM+nEg5\n" "XenI3o1+\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP160r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP160r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MEIwFAYHKoZIzj0CAQYJKyQDAwIIAQEBAyoABH1BciXXV4+UDNWXCMtSeQqPFfos\n" "EBThDSw6jV54Mz6cSDld6cjejX4=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP160t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP160t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MGQCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQECBEkwRwIBAQQU3/XiFisN/54Kj4nQ\n" "Bwjr1dceZQihLAMqAATKWOgm/tH+UYnAv8hs/Y/D34fMv4BwU4k3/Z+gRBKRN4cy\n" "ypd5NiES\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP160t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP160t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MEIwFAYHKoZIzj0CAQYJKyQDAwIIAQECAyoABMpY6Cb+0f5RicC/yGz9j8Pfh8y/\n" "gHBTiTf9n6BEEpE3hzLKl3k2IRI=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP192r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP192r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MHACAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEDBFUwUwIBAQQYZJ2mohQak6UuCZdW\n" "Ox8uUsOp70Pg2T0+oTQDMgAEezNHhaP+k9qgeQ/9ZHAc/AhkWrGNJ8AjwFqrj4lc\n" "EyDnCz3QxK3MEmfPxkhlNXWb\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP192r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP192r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MEowFAYHKoZIzj0CAQYJKyQDAwIIAQEDAzIABHszR4Wj/pPaoHkP/WRwHPwIZFqx\n" "jSfAI8Baq4+JXBMg5ws90MStzBJnz8ZIZTV1mw==\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP192t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP192t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MHACAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEEBFUwUwIBAQQYG9Qnpo0Mnsc038+F\n" "8cL9eend4xNz6blPoTQDMgAECrDcmHkXtKe1+TKqYtM2jfe805qYBR7kgBWmEmJN\n" "KAfv8Oo+/1u/VpNe2nYBURRn\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP192t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP192t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MEowFAYHKoZIzj0CAQYJKyQDAwIIAQEEAzIABAqw3Jh5F7SntfkyqmLTNo33vNOa\n" "mAUe5IAVphJiTSgH7/DqPv9bv1aTXtp2AVEUZw==\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP224r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP224r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MHwCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEFBGEwXwIBAQQcjRIweUszgw6kye8e\n" "uH+EDixtMWACgjAFKLlD86E8AzoABKJPILw4pJ703KZWzwCiU2WIZgaxlHo3M/LI\n" "hOuGsmvnaBmH6nfTt4E7NqHkgBnJVNTmELXpPDt2\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP224r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP224r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MFIwFAYHKoZIzj0CAQYJKyQDAwIIAQEFAzoABKJPILw4pJ703KZWzwCiU2WIZgax\n" "lHo3M/LIhOuGsmvnaBmH6nfTt4E7NqHkgBnJVNTmELXpPDt2\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP224t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP224t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MHwCAQAwFAYHKoZIzj0CAQYJKyQDAwIIAQEGBGEwXwIBAQQc0FrhunNRyAF63WWu\n" "RnlazhSV2vURHyWcGu6deKE8AzoABIdtC73AhzV0Jr90EHl9DHuyQfsrb9917sCj\n" "+4YGoKqXTKp8Ww4dc1dDIxd9FKyz9J///x1RUqUn\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP224t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP224t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MFIwFAYHKoZIzj0CAQYJKyQDAwIIAQEGAzoABIdtC73AhzV0Jr90EHl9DHuyQfsr\n" "b9917sCj+4YGoKqXTKp8Ww4dc1dDIxd9FKyz9J///x1RUqUn\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP256r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP256r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIGIAgEAMBQGByqGSM49AgEGCSskAwMCCAEBBwRtMGsCAQEEIGEWmKHlX2Q7RNcn\n" "TjcbiQO83eOZdeohwj6GrZTswNZYoUQDQgAELXkxbTULz0F0MP9if30WZ2SUw3Sz\n" "Oht9darQcWO6fzUlHzJPAz//wv+narhYYYGO9c9K7YTGSUPA9x3G4l31rA==\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP256r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP256r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MFowFAYHKoZIzj0CAQYJKyQDAwIIAQEHA0IABC15MW01C89BdDD/Yn99FmdklMN0\n" "szobfXWq0HFjun81JR8yTwM//8L/p2q4WGGBjvXPSu2ExklDwPcdxuJd9aw=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP256t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP256t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIGIAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCARtMGsCAQEEICKa3/xdoohLWjrn\n" "mR/5Iyb8yyb6FPAa9R4vTa6x53b+oUQDQgAEgeCO46sHVnF8StJg7SiKW/Nwbw76\n" "Nai8MrlYN8axQN9oEgwrTNVzu0M4X2fquIxI8i52Rp+/iPL50zE8UI4RKA==\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP256t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP256t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MFowFAYHKoZIzj0CAQYJKyQDAwIIAQEIA0IABIHgjuOrB1ZxfErSYO0oilvzcG8O\n" "+jWovDK5WDfGsUDfaBIMK0zVc7tDOF9n6riMSPIudkafv4jy+dMxPFCOESg=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP320r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP320r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIGiAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCQSBhjCBgwIBAQQoQg1ccOHTcKft\n" "H7HYc+bMzIqlWs76bfL9ie1Z7AvZaCHTxdvkXkSnzKFUA1IABA+GdgqTHGQORU7c\n" "oz/8036686oDnSs8kMjNQ4GIdGHcwXiurGviJmO/T+yJAU2wqiTefWGjOpNVzOMJ\n" "HHnad3xgbzrevv5ajO6PUHeI14OP\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP320r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP320r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MGowFAYHKoZIzj0CAQYJKyQDAwIIAQEJA1IABA+GdgqTHGQORU7coz/8036686oD\n" "nSs8kMjNQ4GIdGHcwXiurGviJmO/T+yJAU2wqiTefWGjOpNVzOMJHHnad3xgbzre\n" "vv5ajO6PUHeI14OP\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP320t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP320t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIGiAgEAMBQGByqGSM49AgEGCSskAwMCCAEBCgSBhjCBgwIBAQQoNBUB9bYEND/J\n" "Aa/5LWOwPFVAteMc06veS4FgGuyhTXxwGFJuwvGx56FUA1IABDdabgr6v4yG2hLZ\n" "2zTxP2+vKDwVJaHvBQ8StEkkfYKzKus5hUILOQTEbpi6/ODPw0ZRC1+uK87IuPMu\n" "1DnWIRvDUrSFCcjURCTAwudMTt5y\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP320t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP320t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MGowFAYHKoZIzj0CAQYJKyQDAwIIAQEKA1IABDdabgr6v4yG2hLZ2zTxP2+vKDwV\n" "JaHvBQ8StEkkfYKzKus5hUILOQTEbpi6/ODPw0ZRC1+uK87IuPMu1DnWIRvDUrSF\n" "CcjURCTAwudMTt5y\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP384r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP384r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIG6AgEAMBQGByqGSM49AgEGCSskAwMCCAEBCwSBnjCBmwIBAQQwf+M859VdL3Cx\n" "DUQ6xzEpPbgmHhlMa9veRNok/VlKFwHs7gUpirvA+vzCz1sJA0ePoWQDYgAEgYsV\n" "W0pKIDXz4qWgvqkFLD6yB+99GvXDnMKRQPIHcSOfAnThZtr5LJH/xXMNs29aez3a\n" "TqgYmVtiAQgM+C6shAaqqj6qZoE0ACSgemVKHxV065JStQts9xfqhK2QOey9\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP384r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP384r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MHowFAYHKoZIzj0CAQYJKyQDAwIIAQELA2IABIGLFVtKSiA18+KloL6pBSw+sgfv\n" "fRr1w5zCkUDyB3EjnwJ04Wba+SyR/8VzDbNvWns92k6oGJlbYgEIDPgurIQGqqo+\n" "qmaBNAAkoHplSh8VdOuSUrULbPcX6oStkDnsvQ==\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP384t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP384t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIG6AgEAMBQGByqGSM49AgEGCSskAwMCCAEBDASBnjCBmwIBAQQwaPOGmvKk9UPa\n" "GnpoWTpvs2gmq5C1CC8pMc8aVFPWY4yhUszcnYiIuIMfs+AzMo6CoWQDYgAEdemX\n" "VIj45zsc/28xYiSObxmuf4OskgIvBrptXx8DwJMOmZvFawXswxZErzv13gvmcPMd\n" "rif01/fGgrr/QTQAKx8l/5TkECkHdOflHS84Wy2h1mkbb3KFJH7Opm5JMmtw\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP384t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP384t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MHowFAYHKoZIzj0CAQYJKyQDAwIIAQEMA2IABHXpl1SI+Oc7HP9vMWIkjm8Zrn+D\n" "rJICLwa6bV8fA8CTDpmbxWsF7MMWRK879d4L5nDzHa4n9Nf3xoK6/0E0ACsfJf+U\n" "5BApB3Tn5R0vOFstodZpG29yhSR+zqZuSTJrcA==\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP512r1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP512r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIHsAgEAMBQGByqGSM49AgEGCSskAwMCCAEBDQSB0DCBzQIBAQRAjQ8+FR54Dggv\n" "o5bICxr+k+6fjjeakaYFxwaqlVtznmLdX9WqantFAld3mSRI0fEwa8quplRS/SO1\n" "egRx/i/CbKGBhQOBggAEdtNym0AqquTwWqRH8ardukuoopQQu3dbq30IWsZfyx/h\n" @@ -826,14 +826,14 @@ static string g_testEccBrainpoolP512r1PriKey = "-----BEGIN PRIVATE KEY-----\n" "mbAjSHsKXQRLIk3WCxL4xqXk+GC/Na64lsUnqDIw/ieztxmhkT9O5zLdW6qAKhI=\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP512r1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP512r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDQOBggAEdtNym0AqquTwWqRH8ardukuo\n" "opQQu3dbq30IWsZfyx/hZLMNJWpLVMKcIg0F/qccFlqKvj3kMy6c7keIAMkBKXeC\n" "J+6NKM3cgcKr1crfvagCmbAjSHsKXQRLIk3WCxL4xqXk+GC/Na64lsUnqDIw/iez\n" "txmhkT9O5zLdW6qAKhI=\n" "-----END PUBLIC KEY-----\n"; -static string g_testEccBrainpoolP512t1PriKey = "-----BEGIN PRIVATE KEY-----\n" +static string g_testEccP512t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "MIHsAgEAMBQGByqGSM49AgEGCSskAwMCCAEBDgSB0DCBzQIBAQRAhSMiRfKXVUGS\n" "hMiCfkdszV0TmdWib5WIoNFKyHQGgtt8kZcXl5NX84SsoO28leLDJ9fSd1qV/Dwq\n" "+INCiNKnGaGBhQOBggAEKGhHCsQ5qabxssAoCZiEZT9wxdTOliHqv+mStkwQRPZD\n" @@ -841,7 +841,7 @@ static string g_testEccBrainpoolP512t1PriKey = "-----BEGIN PRIVATE KEY-----\n" "jPT8olwleVaidVbgPjLtliZV98evrcZKZ/x1plcWX7l8I2Bhg5845fximjWUvQU=\n" "-----END PRIVATE KEY-----\n"; -static string g_testEccBrainpoolP512t1PubKey = "-----BEGIN PUBLIC KEY-----\n" +static string g_testEccP512t1PubKey = "-----BEGIN PUBLIC KEY-----\n" "MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDgOBggAEKGhHCsQ5qabxssAoCZiEZT9w\n" "xdTOliHqv+mStkwQRPZDOr4uSUqGTQHXUWY/9+J3fMnvws7uf9p9GnRB9rpHL2K/\n" "NkiviW+hX+ikIuyT7nGrjPT8olwleVaidVbgPjLtliZV98evrcZKZ/x1plcWX7l8\n" @@ -888,7 +888,7 @@ static string g_testEccSecp521r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "mUXBCWuncDOfPrC2HDY=\n" "-----END PUBLIC KEY-----\n"; -static void asyKeyConvertPemTest(const char *algoName, const char *pubKey, const char *priKey) +static void asyKeyConvertPem(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -918,47 +918,47 @@ static void asyKeyConvertPemTest(const char *algoName, const char *pubKey, const HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest001, TestSize.Level0) { - asyKeyConvertPemTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyConvertPemTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyConvertPemTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyConvertPemTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyConvertPemTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyConvertPemTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - - asyKeyConvertPemTest("DH_ffdhe2048", g_testDhFfdhe2048PubKey.c_str(), g_testDhFfdhe2048PriKey.c_str()); - asyKeyConvertPemTest("DH_ffdhe3072", g_testDhFfdhe3072PubKey.c_str(), g_testDhFfdhe3072PriKey.c_str()); - asyKeyConvertPemTest("DH_ffdhe4096", g_testDhFfdhe4096PubKey.c_str(), g_testDhFfdhe4096PriKey.c_str()); - asyKeyConvertPemTest("DH_ffdhe6144", g_testDhFfdhe6144PubKey.c_str(), g_testDhFfdhe6144PriKey.c_str()); - asyKeyConvertPemTest("DH_ffdhe8192", g_testDhFfdhe8192PubKey.c_str(), g_testDhFfdhe8192PriKey.c_str()); - asyKeyConvertPemTest("DH_modp2048", g_testDhModp2048PubKey.c_str(), g_testDhModp2048PriKey.c_str()); - asyKeyConvertPemTest("DH_modp3072", g_testDhModp3072PubKey.c_str(), g_testDhModp3072PriKey.c_str()); - asyKeyConvertPemTest("DH_modp4096", g_testDhModp4096PubKey.c_str(), g_testDhModp4096PriKey.c_str()); - asyKeyConvertPemTest("DH_modp6144", g_testDhModp6144PubKey.c_str(), g_testDhModp6144PriKey.c_str()); - asyKeyConvertPemTest("DH_modp8192", g_testDhModp8192PubKey.c_str(), g_testDhModp8192PriKey.c_str()); - - asyKeyConvertPemTest("DSA2048", g_testDsa2048PubKey.c_str(), g_testDsa2048Prikey.c_str()); - asyKeyConvertPemTest("DSA3072", g_testDsa3072PubKey.c_str(), g_testDsa3072Prikey.c_str()); - - asyKeyConvertPemTest("ECC_BrainPoolP160r1", g_testEccBrainpoolP160r1PubKey.c_str(), g_testEccBrainpoolP160r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP160t1", g_testEccBrainpoolP160t1PubKey.c_str(), g_testEccBrainpoolP160t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP192r1", g_testEccBrainpoolP192r1PubKey.c_str(), g_testEccBrainpoolP192r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP192t1", g_testEccBrainpoolP192t1PubKey.c_str(), g_testEccBrainpoolP192t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP224r1", g_testEccBrainpoolP224r1PubKey.c_str(), g_testEccBrainpoolP224r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP224t1", g_testEccBrainpoolP224t1PubKey.c_str(), g_testEccBrainpoolP224t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP256r1", g_testEccBrainpoolP256r1PubKey.c_str(), g_testEccBrainpoolP256r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP256t1", g_testEccBrainpoolP256t1PubKey.c_str(), g_testEccBrainpoolP256t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP320r1", g_testEccBrainpoolP320r1PubKey.c_str(), g_testEccBrainpoolP320r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP320t1", g_testEccBrainpoolP320t1PubKey.c_str(), g_testEccBrainpoolP320t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP384r1", g_testEccBrainpoolP384r1PubKey.c_str(), g_testEccBrainpoolP384r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP384t1", g_testEccBrainpoolP384t1PubKey.c_str(), g_testEccBrainpoolP384t1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP512r1", g_testEccBrainpoolP512r1PubKey.c_str(), g_testEccBrainpoolP512r1PriKey.c_str()); - asyKeyConvertPemTest("ECC_BrainPoolP512t1", g_testEccBrainpoolP512t1PubKey.c_str(), g_testEccBrainpoolP512t1PriKey.c_str()); - asyKeyConvertPemTest("ECC256", g_testEccPrime256v1PubKey.c_str(), g_testEccPrime256v1PriKey.c_str()); - asyKeyConvertPemTest("ECC384", g_testEccSecp384r1PubKey.c_str(), g_testEccSecp384r1PriKey.c_str()); - asyKeyConvertPemTest("ECC521", g_testEccSecp521r1PubKey.c_str(), g_testEccSecp521r1PriKey.c_str()); + asyKeyConvertPem("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyConvertPem("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyConvertPem("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyConvertPem("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyConvertPem("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyConvertPem("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + + asyKeyConvertPem("DH_ffdhe2048", g_testDhFfdhe2048PubKey.c_str(), g_testDhFfdhe2048PriKey.c_str()); + asyKeyConvertPem("DH_ffdhe3072", g_testDhFfdhe3072PubKey.c_str(), g_testDhFfdhe3072PriKey.c_str()); + asyKeyConvertPem("DH_ffdhe4096", g_testDhFfdhe4096PubKey.c_str(), g_testDhFfdhe4096PriKey.c_str()); + asyKeyConvertPem("DH_ffdhe6144", g_testDhFfdhe6144PubKey.c_str(), g_testDhFfdhe6144PriKey.c_str()); + asyKeyConvertPem("DH_ffdhe8192", g_testDhFfdhe8192PubKey.c_str(), g_testDhFfdhe8192PriKey.c_str()); + asyKeyConvertPem("DH_modp2048", g_testDhModp2048PubKey.c_str(), g_testDhModp2048PriKey.c_str()); + asyKeyConvertPem("DH_modp3072", g_testDhModp3072PubKey.c_str(), g_testDhModp3072PriKey.c_str()); + asyKeyConvertPem("DH_modp4096", g_testDhModp4096PubKey.c_str(), g_testDhModp4096PriKey.c_str()); + asyKeyConvertPem("DH_modp6144", g_testDhModp6144PubKey.c_str(), g_testDhModp6144PriKey.c_str()); + asyKeyConvertPem("DH_modp8192", g_testDhModp8192PubKey.c_str(), g_testDhModp8192PriKey.c_str()); + + asyKeyConvertPem("DSA2048", g_testDsa2048PubKey.c_str(), g_testDsa2048Prikey.c_str()); + asyKeyConvertPem("DSA3072", g_testDsa3072PubKey.c_str(), g_testDsa3072Prikey.c_str()); + + asyKeyConvertPem("ECC_BrainPoolP160r1", g_testEccP160r1PubKey.c_str(), g_testEccP160r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP160t1", g_testEccP160t1PubKey.c_str(), g_testEccP160t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP192r1", g_testEccP192r1PubKey.c_str(), g_testEccP192r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP192t1", g_testEccP192t1PubKey.c_str(), g_testEccP192t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP224r1", g_testEccP224r1PubKey.c_str(), g_testEccP224r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP224t1", g_testEccP224t1PubKey.c_str(), g_testEccP224t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP256r1", g_testEccP256r1PubKey.c_str(), g_testEccP256r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP256t1", g_testEccP256t1PubKey.c_str(), g_testEccP256t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP320r1", g_testEccP320r1PubKey.c_str(), g_testEccP320r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP320t1", g_testEccP320t1PubKey.c_str(), g_testEccP320t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP384r1", g_testEccP384r1PubKey.c_str(), g_testEccP384r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP384t1", g_testEccP384t1PubKey.c_str(), g_testEccP384t1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP512r1", g_testEccP512r1PubKey.c_str(), g_testEccP512r1PriKey.c_str()); + asyKeyConvertPem("ECC_BrainPoolP512t1", g_testEccP512t1PubKey.c_str(), g_testEccP512t1PriKey.c_str()); + asyKeyConvertPem("ECC256", g_testEccPrime256v1PubKey.c_str(), g_testEccPrime256v1PriKey.c_str()); + asyKeyConvertPem("ECC384", g_testEccSecp384r1PubKey.c_str(), g_testEccSecp384r1PriKey.c_str()); + asyKeyConvertPem("ECC521", g_testEccSecp521r1PubKey.c_str(), g_testEccSecp521r1PriKey.c_str()); } -static void asyKeyPemParamNullErrorTest(const char *algoName, const char *pubKey, const char *priKey) +static void asyKeyPemParamNullError(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -983,15 +983,15 @@ static void asyKeyPemParamNullErrorTest(const char *algoName, const char *pubKey // test ConvertPemKey parma is null HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest002, TestSize.Level0) { - asyKeyPemParamNullErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamNullErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamNullErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamNullErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamNullErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamNullErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamNullError("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamNullError("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamNullError("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamNullError("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamNullError("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamNullError("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); } -static void asyKeyPemParamFormatErrorTest(const char *algoName, const char *pubKey, const char *priKey) +static void asyKeyPemParamFormatError(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -1017,15 +1017,15 @@ static void asyKeyPemParamFormatErrorTest(const char *algoName, const char *pubK // test ConvertPemKey pubkey and prikey is invalid HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest003, TestSize.Level0) { - asyKeyPemParamFormatErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamFormatErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamFormatErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamFormatErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamFormatErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamFormatErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamFormatError("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamFormatError("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamFormatError("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamFormatError("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamFormatError("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamFormatError("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); } -static void asyKeyPemParamMatchErrorTest(const char *algoName, const char *pubKey, const char *priKey) +static void asyKeyPemParamMatchError(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -1050,35 +1050,35 @@ static void asyKeyPemParamMatchErrorTest(const char *algoName, const char *pubKe HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest004, TestSize.Level0) { - asyKeyPemParamMatchErrorTest("SM2_256", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("SM2_256", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("SM2_256", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchErrorTest("SM2_256", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchErrorTest("SM2_256", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchErrorTest("X25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchErrorTest("X25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("X25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchErrorTest("X25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchErrorTest("X25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchErrorTest("Ed25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchErrorTest("Ed25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("Ed25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchErrorTest("Ed25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchErrorTest("Ed25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchErrorTest("ECC224", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchErrorTest("ECC224", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("ECC224", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("ECC224", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchErrorTest("ECC224", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DSA1024", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DSA1024", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DSA1024", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DSA1024", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DSA1024", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DH_modp1536", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DH_modp1536", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DH_modp1536", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DH_modp1536", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchErrorTest("DH_modp1536", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchError("SM2_256", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchError("SM2_256", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchError("SM2_256", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchError("SM2_256", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchError("SM2_256", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchError("X25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchError("X25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchError("X25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchError("X25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchError("X25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchError("Ed25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchError("Ed25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchError("Ed25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchError("Ed25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchError("Ed25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchError("ECC224", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchError("ECC224", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchError("ECC224", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchError("ECC224", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + asyKeyPemParamMatchError("ECC224", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchError("DSA1024", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchError("DSA1024", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchError("DSA1024", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchError("DSA1024", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchError("DSA1024", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + asyKeyPemParamMatchError("DH_modp1536", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + asyKeyPemParamMatchError("DH_modp1536", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + asyKeyPemParamMatchError("DH_modp1536", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + asyKeyPemParamMatchError("DH_modp1536", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + asyKeyPemParamMatchError("DH_modp1536", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); } } -- Gitee From 5044cd3c4602561d40501313fdbb3ca0688d2e7a Mon Sep 17 00:00:00 2001 From: hhhFun Date: Sat, 17 Aug 2024 12:58:06 +0000 Subject: [PATCH 08/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=87=BD=E6=95=B0?= =?UTF-8?q?=E5=91=BD=E5=90=8D=E9=A3=8E=E6=A0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- .../src/crypto_asy_key_convert_pem_test.cpp | 168 +++++++++--------- 1 file changed, 84 insertions(+), 84 deletions(-) diff --git a/test/unittest/src/crypto_asy_key_convert_pem_test.cpp b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp index 2462368..2338d36 100644 --- a/test/unittest/src/crypto_asy_key_convert_pem_test.cpp +++ b/test/unittest/src/crypto_asy_key_convert_pem_test.cpp @@ -888,7 +888,7 @@ static string g_testEccSecp521r1PubKey = "-----BEGIN PUBLIC KEY-----\n" "mUXBCWuncDOfPrC2HDY=\n" "-----END PUBLIC KEY-----\n"; -static void asyKeyConvertPem(const char *algoName, const char *pubKey, const char *priKey) +static void AsyKeyConvertPemTest(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -918,47 +918,47 @@ static void asyKeyConvertPem(const char *algoName, const char *pubKey, const cha HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest001, TestSize.Level0) { - asyKeyConvertPem("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyConvertPem("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyConvertPem("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyConvertPem("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyConvertPem("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyConvertPem("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - - asyKeyConvertPem("DH_ffdhe2048", g_testDhFfdhe2048PubKey.c_str(), g_testDhFfdhe2048PriKey.c_str()); - asyKeyConvertPem("DH_ffdhe3072", g_testDhFfdhe3072PubKey.c_str(), g_testDhFfdhe3072PriKey.c_str()); - asyKeyConvertPem("DH_ffdhe4096", g_testDhFfdhe4096PubKey.c_str(), g_testDhFfdhe4096PriKey.c_str()); - asyKeyConvertPem("DH_ffdhe6144", g_testDhFfdhe6144PubKey.c_str(), g_testDhFfdhe6144PriKey.c_str()); - asyKeyConvertPem("DH_ffdhe8192", g_testDhFfdhe8192PubKey.c_str(), g_testDhFfdhe8192PriKey.c_str()); - asyKeyConvertPem("DH_modp2048", g_testDhModp2048PubKey.c_str(), g_testDhModp2048PriKey.c_str()); - asyKeyConvertPem("DH_modp3072", g_testDhModp3072PubKey.c_str(), g_testDhModp3072PriKey.c_str()); - asyKeyConvertPem("DH_modp4096", g_testDhModp4096PubKey.c_str(), g_testDhModp4096PriKey.c_str()); - asyKeyConvertPem("DH_modp6144", g_testDhModp6144PubKey.c_str(), g_testDhModp6144PriKey.c_str()); - asyKeyConvertPem("DH_modp8192", g_testDhModp8192PubKey.c_str(), g_testDhModp8192PriKey.c_str()); - - asyKeyConvertPem("DSA2048", g_testDsa2048PubKey.c_str(), g_testDsa2048Prikey.c_str()); - asyKeyConvertPem("DSA3072", g_testDsa3072PubKey.c_str(), g_testDsa3072Prikey.c_str()); - - asyKeyConvertPem("ECC_BrainPoolP160r1", g_testEccP160r1PubKey.c_str(), g_testEccP160r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP160t1", g_testEccP160t1PubKey.c_str(), g_testEccP160t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP192r1", g_testEccP192r1PubKey.c_str(), g_testEccP192r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP192t1", g_testEccP192t1PubKey.c_str(), g_testEccP192t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP224r1", g_testEccP224r1PubKey.c_str(), g_testEccP224r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP224t1", g_testEccP224t1PubKey.c_str(), g_testEccP224t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP256r1", g_testEccP256r1PubKey.c_str(), g_testEccP256r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP256t1", g_testEccP256t1PubKey.c_str(), g_testEccP256t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP320r1", g_testEccP320r1PubKey.c_str(), g_testEccP320r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP320t1", g_testEccP320t1PubKey.c_str(), g_testEccP320t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP384r1", g_testEccP384r1PubKey.c_str(), g_testEccP384r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP384t1", g_testEccP384t1PubKey.c_str(), g_testEccP384t1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP512r1", g_testEccP512r1PubKey.c_str(), g_testEccP512r1PriKey.c_str()); - asyKeyConvertPem("ECC_BrainPoolP512t1", g_testEccP512t1PubKey.c_str(), g_testEccP512t1PriKey.c_str()); - asyKeyConvertPem("ECC256", g_testEccPrime256v1PubKey.c_str(), g_testEccPrime256v1PriKey.c_str()); - asyKeyConvertPem("ECC384", g_testEccSecp384r1PubKey.c_str(), g_testEccSecp384r1PriKey.c_str()); - asyKeyConvertPem("ECC521", g_testEccSecp521r1PubKey.c_str(), g_testEccSecp521r1PriKey.c_str()); + AsyKeyConvertPemTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyConvertPemTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyConvertPemTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyConvertPemTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyConvertPemTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyConvertPemTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + + AsyKeyConvertPemTest("DH_ffdhe2048", g_testDhFfdhe2048PubKey.c_str(), g_testDhFfdhe2048PriKey.c_str()); + AsyKeyConvertPemTest("DH_ffdhe3072", g_testDhFfdhe3072PubKey.c_str(), g_testDhFfdhe3072PriKey.c_str()); + AsyKeyConvertPemTest("DH_ffdhe4096", g_testDhFfdhe4096PubKey.c_str(), g_testDhFfdhe4096PriKey.c_str()); + AsyKeyConvertPemTest("DH_ffdhe6144", g_testDhFfdhe6144PubKey.c_str(), g_testDhFfdhe6144PriKey.c_str()); + AsyKeyConvertPemTest("DH_ffdhe8192", g_testDhFfdhe8192PubKey.c_str(), g_testDhFfdhe8192PriKey.c_str()); + AsyKeyConvertPemTest("DH_modp2048", g_testDhModp2048PubKey.c_str(), g_testDhModp2048PriKey.c_str()); + AsyKeyConvertPemTest("DH_modp3072", g_testDhModp3072PubKey.c_str(), g_testDhModp3072PriKey.c_str()); + AsyKeyConvertPemTest("DH_modp4096", g_testDhModp4096PubKey.c_str(), g_testDhModp4096PriKey.c_str()); + AsyKeyConvertPemTest("DH_modp6144", g_testDhModp6144PubKey.c_str(), g_testDhModp6144PriKey.c_str()); + AsyKeyConvertPemTest("DH_modp8192", g_testDhModp8192PubKey.c_str(), g_testDhModp8192PriKey.c_str()); + + AsyKeyConvertPemTest("DSA2048", g_testDsa2048PubKey.c_str(), g_testDsa2048Prikey.c_str()); + AsyKeyConvertPemTest("DSA3072", g_testDsa3072PubKey.c_str(), g_testDsa3072Prikey.c_str()); + + AsyKeyConvertPemTest("ECC_BrainPoolP160r1", g_testEccP160r1PubKey.c_str(), g_testEccP160r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP160t1", g_testEccP160t1PubKey.c_str(), g_testEccP160t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP192r1", g_testEccP192r1PubKey.c_str(), g_testEccP192r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP192t1", g_testEccP192t1PubKey.c_str(), g_testEccP192t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP224r1", g_testEccP224r1PubKey.c_str(), g_testEccP224r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP224t1", g_testEccP224t1PubKey.c_str(), g_testEccP224t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP256r1", g_testEccP256r1PubKey.c_str(), g_testEccP256r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP256t1", g_testEccP256t1PubKey.c_str(), g_testEccP256t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP320r1", g_testEccP320r1PubKey.c_str(), g_testEccP320r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP320t1", g_testEccP320t1PubKey.c_str(), g_testEccP320t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP384r1", g_testEccP384r1PubKey.c_str(), g_testEccP384r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP384t1", g_testEccP384t1PubKey.c_str(), g_testEccP384t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP512r1", g_testEccP512r1PubKey.c_str(), g_testEccP512r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC_BrainPoolP512t1", g_testEccP512t1PubKey.c_str(), g_testEccP512t1PriKey.c_str()); + AsyKeyConvertPemTest("ECC256", g_testEccPrime256v1PubKey.c_str(), g_testEccPrime256v1PriKey.c_str()); + AsyKeyConvertPemTest("ECC384", g_testEccSecp384r1PubKey.c_str(), g_testEccSecp384r1PriKey.c_str()); + AsyKeyConvertPemTest("ECC521", g_testEccSecp521r1PubKey.c_str(), g_testEccSecp521r1PriKey.c_str()); } -static void asyKeyPemParamNullError(const char *algoName, const char *pubKey, const char *priKey) +static void AsyKeyPemParamNullErrorTest(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -983,15 +983,15 @@ static void asyKeyPemParamNullError(const char *algoName, const char *pubKey, co // test ConvertPemKey parma is null HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest002, TestSize.Level0) { - asyKeyPemParamNullError("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamNullError("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamNullError("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamNullError("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamNullError("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamNullError("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamNullErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamNullErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamNullErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamNullErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamNullErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamNullErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); } -static void asyKeyPemParamFormatError(const char *algoName, const char *pubKey, const char *priKey) +static void AsyKeyPemParamFormatErrorTest(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -1017,15 +1017,15 @@ static void asyKeyPemParamFormatError(const char *algoName, const char *pubKey, // test ConvertPemKey pubkey and prikey is invalid HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest003, TestSize.Level0) { - asyKeyPemParamFormatError("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamFormatError("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamFormatError("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamFormatError("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamFormatError("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamFormatError("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamFormatErrorTest("SM2_256", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamFormatErrorTest("X25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamFormatErrorTest("Ed25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamFormatErrorTest("ECC224", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamFormatErrorTest("DSA1024", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamFormatErrorTest("DH_modp1536", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); } -static void asyKeyPemParamMatchError(const char *algoName, const char *pubKey, const char *priKey) +static void AsyKeyPemParamMatchErrorTest(const char *algoName, const char *pubKey, const char *priKey) { HcfAsyKeyGenerator *generator = nullptr; HcfResult res = HcfAsyKeyGeneratorCreate(algoName, &generator); @@ -1050,35 +1050,35 @@ static void asyKeyPemParamMatchError(const char *algoName, const char *pubKey, c HWTEST_F(CryptoAsyKeyConvertPemTest, CryptoAsyKeyConvertPemTest004, TestSize.Level0) { - asyKeyPemParamMatchError("SM2_256", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchError("SM2_256", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchError("SM2_256", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchError("SM2_256", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchError("SM2_256", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchError("X25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchError("X25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchError("X25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchError("X25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchError("X25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchError("Ed25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchError("Ed25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchError("Ed25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchError("Ed25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchError("Ed25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchError("ECC224", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchError("ECC224", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchError("ECC224", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchError("ECC224", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); - asyKeyPemParamMatchError("ECC224", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchError("DSA1024", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchError("DSA1024", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchError("DSA1024", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchError("DSA1024", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchError("DSA1024", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); - asyKeyPemParamMatchError("DH_modp1536", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); - asyKeyPemParamMatchError("DH_modp1536", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); - asyKeyPemParamMatchError("DH_modp1536", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); - asyKeyPemParamMatchError("DH_modp1536", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); - asyKeyPemParamMatchError("DH_modp1536", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamMatchErrorTest("SM2_256", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("SM2_256", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("SM2_256", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("SM2_256", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamMatchErrorTest("SM2_256", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("X25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("X25519", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("X25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("X25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamMatchErrorTest("X25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("Ed25519", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("Ed25519", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("Ed25519", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("Ed25519", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamMatchErrorTest("Ed25519", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("ECC224", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("ECC224", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("ECC224", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("ECC224", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); + AsyKeyPemParamMatchErrorTest("ECC224", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DSA1024", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DSA1024", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DSA1024", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DSA1024", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DSA1024", g_testDhModp1536PubKey.c_str(), g_testDhModp1536PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DH_modp1536", g_testSm2PubKey.c_str(), g_testSm2PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DH_modp1536", g_testX25519PubKey.c_str(), g_testX25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DH_modp1536", g_testEd25519PubKey.c_str(), g_testEd25519PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DH_modp1536", g_testEccSecp224r1PubKey.c_str(), g_testEccSecp224r1PriKey.c_str()); + AsyKeyPemParamMatchErrorTest("DH_modp1536", g_testDsa1024Pubkey.c_str(), g_testDsa1024Prikey.c_str()); } } -- Gitee From 5aa68341528bb5f0e532f573621000a54399ac62 Mon Sep 17 00:00:00 2001 From: lcc Date: Fri, 23 Aug 2024 22:54:17 +0800 Subject: [PATCH 09/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=99=BD=E7=9B=92?= =?UTF-8?q?=E6=A3=80=E8=A7=86issue?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- .../crypto/src/napi_asy_key_generator.cpp | 9 ++++++--- frameworks/js/napi/crypto/src/napi_cipher.cpp | 6 ++---- .../js/napi/crypto/src/napi_pri_key.cpp | 19 +++++++++++++++++++ .../js/napi/crypto/src/napi_pub_key.cpp | 18 ++++++++++++++++++ frameworks/js/napi/crypto/src/napi_sign.cpp | 6 +++--- frameworks/js/napi/crypto/src/napi_verify.cpp | 8 ++++---- 6 files changed, 52 insertions(+), 14 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..a3aff13 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -903,8 +903,12 @@ napi_value NapiAsyKeyGenerator::JsConvertPemKeySync(napi_env env, napi_callback_ return nullptr; } - napi_value instance = nullptr; - instance = napiKeyPair->ConvertToJsKeyPair(env); + napi_value instance = napiKeyPair->ConvertToJsKeyPair(env); + if (instance == nullptr) { + LOGE("covert to jsKeyPair failed!"); + instance = NapiGetNull(env); + } + return instance; } @@ -936,7 +940,6 @@ static napi_value NapiWrapAsyKeyGen(napi_env env, napi_value instance, NapiAsyKe napi_value NapiAsyKeyGenerator::CreateJsAsyKeyGenerator(napi_env env, napi_callback_info info) { - LOGD("Enter CreateJsAsyKeyGenerator..."); size_t expectedArgc = PARAMS_NUM_ONE; size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; diff --git a/frameworks/js/napi/crypto/src/napi_cipher.cpp b/frameworks/js/napi/crypto/src/napi_cipher.cpp index 0e404dc..1b7a977 100644 --- a/frameworks/js/napi/crypto/src/napi_cipher.cpp +++ b/frameworks/js/napi/crypto/src/napi_cipher.cpp @@ -851,12 +851,10 @@ napi_value NapiCipher::JsSetCipherSpec(napi_env env, napi_callback_info info) LOGE("get JsGetCipherSpecUint8Array failed!"); return nullptr; } - HcfBlob *pSource = nullptr; - pSource = GetBlobFromNapiUint8Arr(env, argv[1]); + HcfBlob *pSource = GetBlobFromNapiUint8Arr(env, argv[1]); if (pSource == nullptr || pSource->len == 0) { LOGE("failed to get pSource."); - napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, - "[pSource]: must be of the DataBlob type.")); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "[pSource]: must be of the DataBlob type.")); return nullptr; } napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiCipher)); diff --git a/frameworks/js/napi/crypto/src/napi_pri_key.cpp b/frameworks/js/napi/crypto/src/napi_pri_key.cpp index ffc93b4..8f2a046 100644 --- a/frameworks/js/napi/crypto/src/napi_pri_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pri_key.cpp @@ -90,6 +90,12 @@ napi_value NapiPriKey::JsGetEncoded(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); + if (instance == nullptr) { + HcfBlobDataFree(&returnBlob); + napi_throw(env, GenerateBusinessError(env, res, "covert blob to napi value failed.")); + LOGE("covert blob to napi value failed."); + return nullptr; + } HcfBlobDataFree(&returnBlob); return instance; } @@ -176,6 +182,12 @@ static napi_value GetAsyKeySpecBigInt(napi_env env, AsyKeySpecItem item, HcfPriK } napi_value instance = ConvertBigIntToNapiValue(env, &returnBigInteger); + if (instance == nullptr) { + HcfFree(returnBigInteger.data); + napi_throw(env, GenerateBusinessError(env, res, "covert bigInt to napi value failed.")); + LOGE("covert bigInt to napi value failed."); + return nullptr; + } HcfFree(returnBigInteger.data); return instance; } @@ -296,7 +308,14 @@ napi_value NapiPriKey::JsGetEncodedDer(napi_env env, napi_callback_info info) LOGE("get private key encodeDer fail."); return nullptr; } + napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); + if (instance == nullptr) { + HcfBlobDataFree(&returnBlob); + napi_throw(env, GenerateBusinessError(env, res, "covert blob to napi value failed.")); + LOGE("covert blob to napi value failed."); + return nullptr; + } HcfBlobDataFree(&returnBlob); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_pub_key.cpp b/frameworks/js/napi/crypto/src/napi_pub_key.cpp index 38109e7..675cba1 100644 --- a/frameworks/js/napi/crypto/src/napi_pub_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pub_key.cpp @@ -90,6 +90,12 @@ napi_value NapiPubKey::JsGetEncoded(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); + if (instance == nullptr) { + HcfBlobDataFree(&returnBlob); + napi_throw(env, GenerateBusinessError(env, res, "covert blob to napi value failed.")); + LOGE("covert blob to napi value failed."); + return nullptr; + } HcfBlobDataFree(&returnBlob); return instance; } @@ -136,6 +142,12 @@ napi_value NapiPubKey::JsGetEncodedDer(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); + if (instance == nullptr) { + HcfBlobDataFree(&returnBlob); + napi_throw(env, GenerateBusinessError(env, res, "covert blob to napi value failed.")); + LOGE("covert blob to napi value failed."); + return nullptr; + } HcfBlobDataFree(&returnBlob); return instance; } @@ -199,6 +211,12 @@ static napi_value GetAsyKeySpecBigInt(napi_env env, AsyKeySpecItem item, HcfPubK } napi_value instance = ConvertBigIntToNapiValue(env, &returnBigInteger); + if (instance == nullptr) { + HcfFree(returnBigInteger.data); + napi_throw(env, GenerateBusinessError(env, res, "covert bigInt to napi value failed.")); + LOGE("covert bigInt to napi value failed."); + return nullptr; + } HcfFree(returnBigInteger.data); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_sign.cpp b/frameworks/js/napi/crypto/src/napi_sign.cpp index cf7fc77..9f09012 100644 --- a/frameworks/js/napi/crypto/src/napi_sign.cpp +++ b/frameworks/js/napi/crypto/src/napi_sign.cpp @@ -170,7 +170,7 @@ static bool BuildSignJsInitCtx(napi_env env, napi_callback_info info, SignInitCt napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != expectedArgc && argc != expectedArgc - 1) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); @@ -220,7 +220,7 @@ static bool BuildSignJsUpdateCtx(napi_env env, napi_callback_info info, SignUpda napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); @@ -263,7 +263,7 @@ static bool BuildSignJsDoFinalCtx(napi_env env, napi_callback_info info, SignDoF napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index 47319d9..c0f0427 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -214,7 +214,7 @@ static bool BuildVerifyJsInitCtx(napi_env env, napi_callback_info info, VerifyIn napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); @@ -264,7 +264,7 @@ static bool BuildVerifyJsUpdateCtx(napi_env env, napi_callback_info info, Verify napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_TWO; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); @@ -362,7 +362,7 @@ static bool BuildVerifyJsDoFinalCtx(napi_env env, napi_callback_info info, Verif napi_value thisVar = nullptr; size_t expectedArgc = PARAMS_NUM_THREE; size_t argc = expectedArgc; - napi_value argv[PARAMS_NUM_THREE] = { nullptr, nullptr, nullptr }; + napi_value argv[PARAMS_NUM_THREE] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if ((argc != expectedArgc) && (argc != expectedArgc - 1)) { LOGE("wrong argument num. require %zu or %zu arguments. [Argc]: %zu!", expectedArgc - 1, expectedArgc, argc); @@ -849,7 +849,7 @@ napi_value NapiVerify::JsVerifySync(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; size_t argc = PARAMS_NUM_TWO; - napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); if (argc != PARAMS_NUM_TWO) { LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_TWO, argc); -- Gitee From 324dd420f071a359a9c6ecfff6422e92153607fc Mon Sep 17 00:00:00 2001 From: hhhFun Date: Fri, 23 Aug 2024 22:58:31 +0800 Subject: [PATCH 10/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9AI=E6=89=AB=E6=8F=8F?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- frameworks/js/napi/crypto/src/napi_verify.cpp | 5 +++++ frameworks/key/dh_key_util.c | 2 +- .../hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp | 6 ++++++ .../hcfkeyagreementcreate_fuzzer.cpp | 3 +++ test/unittest/src/rsa_common_param_spec.cpp | 3 +++ test/unittest/src/sm4_common.cpp | 4 ++-- 6 files changed, 20 insertions(+), 3 deletions(-) diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index c0f0427..e51a801 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -816,6 +816,11 @@ napi_value NapiVerify::JsUpdateSync(napi_env env, napi_callback_info info) } HcfVerify *verify = napiVerify->GetVerify(); + if (verify == nullptr) { + LOGE("failed to get verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "fail to get verify obj.")); + return nullptr; + } ret = verify->update(verify, &blob); HcfBlobDataFree(&blob); if (ret != HCF_SUCCESS) { diff --git a/frameworks/key/dh_key_util.c b/frameworks/key/dh_key_util.c index d04952f..af6c831 100644 --- a/frameworks/key/dh_key_util.c +++ b/frameworks/key/dh_key_util.c @@ -44,7 +44,7 @@ HcfResult HcfDhKeyUtilCreate(int32_t pLen, int32_t skLen, HcfDhCommParamsSpec ** } ret = CreateDhCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec); if (ret != HCF_SUCCESS) { - LOGE("Failed to create spi object!"); + LOGE("Failed to create spi impl object!"); } FreeDhCommParamsSpec(&(spiInstance->paramsSpec)); HcfFree(spiInstance); diff --git a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp index 7b37ad4..85dc0af 100755 --- a/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp +++ b/test/fuzztest/crypto_operation/hcfciphercreate_fuzzer/hcfciphercreate_fuzzer.cpp @@ -70,6 +70,9 @@ namespace OHOS { uint8_t *cipherText, int cipherTextLen) { HcfBlob output = {}; + if (cipherTextLen <= 0) { + return -1; + } int32_t maxLen = cipherTextLen; int32_t ret = cipher->init(cipher, DECRYPT_MODE, &(key->key), nullptr); if (ret != 0) { @@ -149,6 +152,9 @@ namespace OHOS { uint8_t *cipherText, int cipherTextLen) { HcfBlob output = {}; + if (cipherTextLen <= 0) { + return -1; + } int32_t maxLen = cipherTextLen; int32_t ret = cipher->init(cipher, DECRYPT_MODE, reinterpret_cast(key), nullptr); if (ret != 0) { diff --git a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp index bccfbdb..8a21288 100755 --- a/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp +++ b/test/fuzztest/crypto_operation/hcfkeyagreementcreate_fuzzer/hcfkeyagreementcreate_fuzzer.cpp @@ -26,6 +26,9 @@ namespace OHOS { bool HcfKeyAgreementCreateFuzzTest(const uint8_t* data, size_t size) { + if (data == nullptr || size == 0) { + return false; + } HcfKeyAgreement *keyAgreement = nullptr; std::string algoName(reinterpret_cast(data), size); int32_t res = HcfKeyAgreementCreate(algoName.c_str(), &keyAgreement); diff --git a/test/unittest/src/rsa_common_param_spec.cpp b/test/unittest/src/rsa_common_param_spec.cpp index e7efc4d..f6537f4 100644 --- a/test/unittest/src/rsa_common_param_spec.cpp +++ b/test/unittest/src/rsa_common_param_spec.cpp @@ -47,6 +47,9 @@ void EndianSwap(unsigned char *pData, int startIndex, int length) // 512 defined the length of byte array void GenerateRsa512CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec) { + if (dataN == nullptr) { + return; + } RemoveLastChar(CORRECT_512_N, dataN, RSA_512_N_BYTE_SIZE); if (!IsBigEndian()) { // the device is not big endian diff --git a/test/unittest/src/sm4_common.cpp b/test/unittest/src/sm4_common.cpp index e6953c8..bba4858 100644 --- a/test/unittest/src/sm4_common.cpp +++ b/test/unittest/src/sm4_common.cpp @@ -37,7 +37,7 @@ HcfResult GenerateSm4SymKey(HcfSymKey **key) HcfSymKeyGenerator *generator = nullptr; HcfResult ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); - if (ret != HCF_SUCCESS) { + if (ret != HCF_SUCCESS || generator == nullptr) { LOGE("HcfSymKeyGeneratorCreate failed!"); return ret; } @@ -55,7 +55,7 @@ int32_t GenerateSymKeyForSm4(const char *algoName, HcfSymKey **key) HcfSymKeyGenerator *generator = nullptr; int32_t ret = HcfSymKeyGeneratorCreate(algoName, &generator); - if (ret != 0) { + if (ret != 0 || generator == nullptr) { LOGE("HcfSymKeyGeneratorCreate failed!"); return ret; } -- Gitee From a9955116cdf4d046d1abe19c229c2b4259a995ff Mon Sep 17 00:00:00 2001 From: hhhFun Date: Sat, 24 Aug 2024 15:42:31 +0800 Subject: [PATCH 11/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E5=9F=BA=E7=A1=80=E6=95=B0=E6=8D=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- test/fuzztest/key/asykeygenerator_fuzzer/corpus/init | 2 +- test/fuzztest/key/ecckeyutil_fuzzer/corpus/init | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init b/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init index 2be750d..f760315 100755 --- a/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init +++ b/test/fuzztest/key/asykeygenerator_fuzzer/corpus/init @@ -11,4 +11,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -FUZZ \ No newline at end of file +RSA1024 \ No newline at end of file diff --git a/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init b/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init index 23e26fe..a2291ef 100644 --- a/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init +++ b/test/fuzztest/key/ecckeyutil_fuzzer/corpus/init @@ -11,4 +11,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -FUZZ \ No newline at end of file +NID_brainpoolP160r1 \ No newline at end of file -- Gitee From fa55de0b431fc1d776383b0cebb01cf958c721bd Mon Sep 17 00:00:00 2001 From: lanming Date: Sat, 24 Aug 2024 18:02:13 +0800 Subject: [PATCH 12/32] fix issue Signed-off-by: lanming --- .../cipher/src/cipher_rsa_openssl.c | 1 + .../crypto_operation/kdf/src/hkdf_openssl.c | 6 ------ .../crypto_operation/md/src/md_openssl.c | 2 +- .../crypto_operation/rand/src/rand_openssl.c | 1 + .../crypto_operation/signature/src/dsa_openssl.c | 11 +++-------- .../crypto_operation/signature/src/ecdsa_openssl.c | 11 +++-------- .../signature/src/signature_rsa_openssl.c | 13 +++++-------- .../src/alg_25519_asy_key_generator_openssl.c | 9 +++++++-- 8 files changed, 21 insertions(+), 33 deletions(-) diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c index 3c79681..13aaecc 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c @@ -122,6 +122,7 @@ static HcfResult InitEvpPkeyCtx(HcfCipherRsaGeneratorSpiImpl *impl, HcfKey *key, HcfPrintOpensslError(); OpensslEvpPkeyFree(pkey); OpensslEvpPkeyCtxFree(impl->ctx); + impl->ctx = NULL; return HCF_ERR_CRYPTO_OPERATION; } OpensslEvpPkeyFree(pkey); diff --git a/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c b/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c index 4f3f2b5..a0ca0b9 100644 --- a/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c @@ -202,12 +202,6 @@ static HcfResult InitHkdfData(OpensslHkdfSpiImpl *self, HcfHkdfParamsSpec *param LOGE("malloc info failed!"); break; } - data->out = (unsigned char *)HcfMalloc(params->output.len, 0); - if (data->out == NULL) { - LOGE("malloc out failed!"); - break; - } - data->outLen = params->output.len; self->kdfData = data; return HCF_SUCCESS; } while (0); diff --git a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c index 58f62f5..aa63579 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -136,7 +136,7 @@ static void OpensslDestroyMd(HcfObjectBase *self) HcfResult OpensslMdSpiCreate(const char *opensslAlgoName, HcfMdSpi **spiObj) { - if (spiObj == NULL) { + if (spiObj == NULL || opensslAlgoName == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } diff --git a/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c b/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c index 8ba2e17..e68075a 100644 --- a/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c @@ -75,6 +75,7 @@ static const char *GetRandAlgoName(HcfRandSpi *self) static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { + (void)self; OpensslRandSeed(seed->data, seed->len); } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c index 2debcae..03fb3f1 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/dsa_openssl.c @@ -378,20 +378,15 @@ static HcfResult EngineDsaSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob * LOGE("Failed to allocate signatureData memory!"); return HCF_ERR_MALLOC; } - size_t actualLen = maxLen; - if (OpensslEvpDigestSignFinal(impl->mdCtx, signatureData, &actualLen) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpDigestSignFinal(impl->mdCtx, signatureData, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); HcfFree(signatureData); return HCF_ERR_CRYPTO_OPERATION; } - if (actualLen > maxLen) { - LOGD("[error] Signature data too long."); - HcfFree(signatureData); - return HCF_ERR_CRYPTO_OPERATION; - } returnSignatureData->data = signatureData; - returnSignatureData->len = (uint32_t)actualLen; + returnSignatureData->len = (uint32_t)maxLen; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c index d369fb8..3c8f671 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/ecdsa_openssl.c @@ -225,21 +225,16 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret LOGE("Failed to allocate outData memory!"); return HCF_ERR_MALLOC; } - size_t actualLen = maxLen; - if (OpensslEvpDigestSignFinal(impl->ctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpDigestSignFinal(impl->ctx, outData, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); LOGD("[error] EVP_DigestSignFinal failed."); HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; } - if (actualLen > maxLen) { - LOGD("[error] signature data too long."); - HcfFree(outData); - return HCF_ERR_CRYPTO_OPERATION; - } returnSignatureData->data = outData; - returnSignatureData->len = (uint32_t)actualLen; + returnSignatureData->len = (uint32_t)maxLen; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c index fa11d7b..fc19d25 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c @@ -251,6 +251,7 @@ static HcfResult SetSignParams(HcfSignSpiRsaOpensslImpl *impl, HcfPriKey *privat EVP_MD *opensslAlg = NULL; (void)GetOpensslDigestAlg(impl->md, &opensslAlg); if (opensslAlg == NULL) { + OpensslEvpPkeyFree(dupKey); LOGE("Get openssl digest alg fail"); return HCF_INVALID_PARAMS; } @@ -318,6 +319,7 @@ static HcfResult SetVerifyParams(HcfVerifySpiRsaOpensslImpl *impl, HcfPubKey *pu EVP_MD *opensslAlg = NULL; (void)GetOpensslDigestAlg(impl->md, &opensslAlg); if (opensslAlg == NULL) { + OpensslEvpPkeyFree(dupKey); LOGE("Get openssl digest alg fail"); return HCF_INVALID_PARAMS; } @@ -529,20 +531,15 @@ static HcfResult EngineDigestSign(HcfSignSpiRsaOpensslImpl *impl, HcfBlob *data, LOGE("Failed to allocate outData memory!"); return HCF_ERR_MALLOC; } - size_t actualLen = maxLen; - if (OpensslEvpDigestSignFinal(impl->mdctx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpDigestSignFinal(impl->mdctx, outData, &maxLen) != HCF_OPENSSL_SUCCESS) { LOGD("[error] OpensslEvpDigestSignFinal fail"); HcfFree(outData); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } - if (actualLen > maxLen) { - LOGD("[error] signature data too long."); - HcfFree(outData); - return HCF_ERR_CRYPTO_OPERATION; - } returnSignatureData->data = outData; - returnSignatureData->len = (uint32_t)actualLen; + returnSignatureData->len = (uint32_t)maxLen; return HCF_SUCCESS; } 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 759173f..467eed4 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 @@ -67,10 +67,15 @@ static const char *GetAlg25519PriKeyClass(void) static void DestroyAlg25519KeyGeneratorSpiImpl(HcfObjectBase *self) { - if (self == NULL) { + if ((self == NULL) || (self->getClass() == NULL)) { LOGE("Invalid input parameter."); - return; + return; } + + if (strcmp(obj->getClass(), GetEd25519KeyGeneratorSpiClass()) != 0 && ) { + return true; + } + if (!HcfIsClassMatch(self, GetEd25519KeyGeneratorSpiClass()) && !HcfIsClassMatch(self, GetX25519KeyGeneratorSpiClass())) { LOGE("Invalid class of self."); -- Gitee From b2f1c461eaecdc1635d3e1d5be5509522593ae69 Mon Sep 17 00:00:00 2001 From: lanming Date: Sat, 24 Aug 2024 18:02:13 +0800 Subject: [PATCH 13/32] fix issue Signed-off-by: lanming --- plugin/openssl_plugin/common/src/openssl_common.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 275cf33..83d82af 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -537,20 +537,17 @@ HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret) ret = HCF_ERR_MALLOC; break; } - size_t actualLen = maxLen; - if (OpensslEvpPkeyDerive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpPkeyDerive(ctx, secretData, &maxLen) != HCF_OPENSSL_SUCCESS) { + (void)memset_s(secretData, maxLen, 0, maxLen); LOGD("[error] Evp key derive failed!"); HcfPrintOpensslError(); HcfFree(secretData); break; } - if (actualLen > maxLen) { - LOGD("[error] signature data too long."); - HcfFree(secretData); - break; - } + returnSecret->data = secretData; - returnSecret->len = actualLen; + returnSecret->len = maxLen; ret = HCF_SUCCESS; } while (0); OpensslEvpPkeyCtxFree(ctx); -- Gitee From 7e10d3041552ce661450fda6b754eac7e6d55a60 Mon Sep 17 00:00:00 2001 From: lanming Date: Sat, 24 Aug 2024 19:10:29 +0800 Subject: [PATCH 14/32] Modify review issues Signed-off-by: lanming --- common/src/asy_key_params.c | 8 +++--- common/src/hcf_parcel.c | 4 +-- common/src/object_base.c | 5 ++-- frameworks/key/asy_key_generator.c | 25 +++++++++---------- frameworks/key/ecc_key_util.c | 8 +++--- frameworks/key/sym_key_generator.c | 5 ++-- frameworks/native/src/asym_key.c | 39 +++++++++++++++++++++--------- frameworks/native/src/digest.c | 10 ++++---- frameworks/native/src/signature.c | 26 ++++++++++++++------ frameworks/native/src/sym_cipher.c | 10 ++++---- frameworks/native/src/sym_key.c | 14 +++++------ 11 files changed, 91 insertions(+), 63 deletions(-) diff --git a/common/src/asy_key_params.c b/common/src/asy_key_params.c index 2284349..403b420 100644 --- a/common/src/asy_key_params.c +++ b/common/src/asy_key_params.c @@ -214,9 +214,11 @@ void DestroyEccPriKeySpec(HcfEccPriKeyParamsSpec *spec) return; } FreeEccCommParamsSpec(&(spec->base)); - (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len); - HcfFree(spec->sk.data); - spec->sk.data = NULL; + if (spec->sk.data != NULL) { + (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len); + HcfFree(spec->sk.data); + spec->sk.data = NULL; + } HcfFree(spec); } diff --git a/common/src/hcf_parcel.c b/common/src/hcf_parcel.c index beb9667..410f8e7 100644 --- a/common/src/hcf_parcel.c +++ b/common/src/hcf_parcel.c @@ -66,7 +66,7 @@ uint32_t GetParcelDataSize(const HcParcel *parcel) const char *GetParcelData(const HcParcel *parcel) { - if (parcel == NULL) { + if (parcel == NULL || parcel->data == NULL) { return NULL; } return parcel->data + parcel->beginPos; @@ -145,7 +145,7 @@ static uint32_t GetParcelIncreaseSize(HcParcel *parcel, uint32_t newSize) bool ParcelWrite(HcParcel *parcel, const void *src, uint32_t dataSize) { errno_t rc; - if (parcel == NULL || src == NULL || dataSize == 0) { + if (parcel == NULL || parcel->data == NULL || src == NULL || dataSize == 0) { return false; } if (parcel->endPos > PARCEL_UINT_MAX - dataSize) { diff --git a/common/src/object_base.c b/common/src/object_base.c index d3ff917..3df1ee6 100644 --- a/common/src/object_base.c +++ b/common/src/object_base.c @@ -19,7 +19,8 @@ void HcfObjDestroy(void *obj) { - if (obj != NULL) { - ((HcfObjectBase *)obj)->destroy((HcfObjectBase *)obj); + HcfObjectBase *tmp = (HcfObjectBase *)obj; + if (tmp != NULL && tmp->destory != NULL) { + tmp->destroy(tmp); } } diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index c3ff4bf..4317eeb 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -723,7 +723,6 @@ static HcfResult CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec *srcSpec, Hc spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0); if (spec->pk.data == NULL) { LOGE("Failed to allocate public key memory"); - FreeDhCommParamsSpec(&(spec->base)); DestroyDhPubKeySpec(spec); return HCF_ERR_MALLOC; } @@ -1226,28 +1225,28 @@ static const char *GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec *self) static HcfResult ConvertKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob, HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair) { - if (self == NULL) { + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineConvertKey == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; return impl->spiObj->engineConvertKey(impl->spiObj, params, pubKeyBlob, priKeyBlob, returnKeyPair); } static HcfResult ConvertPemKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, const char *pubKeyStr, const char *priKeyStr, HcfKeyPair **returnKeyPair) { - if (self == NULL) { + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineConvertPemKey == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; return impl->spiObj->engineConvertPemKey(impl->spiObj, params, pubKeyStr, priKeyStr, returnKeyPair); } @@ -1255,53 +1254,53 @@ static HcfResult GenerateKeyPair(HcfAsyKeyGenerator *self, HcfParamsSpec *params HcfKeyPair **returnKeyPair) { (void)params; - if (self == NULL) { + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPair == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; return impl->spiObj->engineGenerateKeyPair(impl->spiObj, returnKeyPair); } static HcfResult GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfKeyPair **returnKeyPair) { - if (self == NULL) { + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPairBySpec == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; return impl->spiObj->engineGenerateKeyPairBySpec(impl->spiObj, impl->paramsSpec, returnKeyPair); } static HcfResult GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPubKey **returnPubKey) { - if (self == NULL) { + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGeneratePubKeyBySpec == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; return impl->spiObj->engineGeneratePubKeyBySpec(impl->spiObj, impl->paramsSpec, returnPubKey); } static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPriKey **returnPriKey) { - if (self == NULL) { + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGeneratePriKeyBySpec == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; return impl->spiObj->engineGeneratePriKeyBySpec(impl->spiObj, impl->paramsSpec, returnPriKey); } diff --git a/frameworks/key/ecc_key_util.c b/frameworks/key/ecc_key_util.c index 8e81d14..a57abb4 100644 --- a/frameworks/key/ecc_key_util.c +++ b/frameworks/key/ecc_key_util.c @@ -185,13 +185,11 @@ HcfResult HcfEccKeyUtilCreate(const char *algName, HcfEccCommParamsSpec **return LOGE("Failed to create spi object!"); return ret; } - if (CreateEccCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec) != HCF_SUCCESS) { + ret = CreateEccCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec) + if (ret != HCF_SUCCESS) { LOGE("Failed to create spi object!"); - FreeEccCommParamsSpec(&(spiInstance->paramsSpec)); - HcfFree(spiInstance); - return ret; } FreeEccCommParamsSpec(&(spiInstance->paramsSpec)); HcfFree(spiInstance); - return HCF_SUCCESS; + return ret; } diff --git a/frameworks/key/sym_key_generator.c b/frameworks/key/sym_key_generator.c index 9295cf3..fa276c1 100644 --- a/frameworks/key/sym_key_generator.c +++ b/frameworks/key/sym_key_generator.c @@ -206,7 +206,7 @@ static void DestroySymmKeyGenerator(HcfObjectBase *base) static HcfResult GenerateSymmKey(HcfSymKeyGenerator *self, HcfSymKey **symmKey) { - if ((self == NULL) || (symmKey == NULL)) { + if ((self == NULL) || (symmKey == NULL) || impl->spiObj == NULL || impl->spiObj->engineGenerateSymmKey == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -222,7 +222,8 @@ static HcfResult GenerateSymmKey(HcfSymKeyGenerator *self, HcfSymKey **symmKey) static HcfResult ConvertSymmKey(HcfSymKeyGenerator *self, const HcfBlob *key, HcfSymKey **symmKey) { - if ((self == NULL) || (symmKey == NULL) || !HcfIsBlobValid(key)) { + if ((self == NULL) || (symmKey == NULL) || !HcfIsBlobValid(key) || impl->spiObj == NULL || + impl->spiObj->engineConvertSymmKey == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c index 2295e0e..8959d00 100644 --- a/frameworks/native/src/asym_key.c +++ b/frameworks/native/src/asym_key.c @@ -74,7 +74,7 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Create(const char *algoName, OH_Cryp OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Generate(OH_CryptoAsymKeyGenerator *ctx, OH_CryptoKeyPair **keyCtx) { - if ((ctx == NULL) || (keyCtx == NULL)) { + if ((ctx == NULL) || (ctx->generateKeyPair == NULL) || (keyCtx == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->generateKeyPair((HcfAsyKeyGenerator *)ctx, NULL, (HcfKeyPair **)keyCtx); @@ -92,11 +92,14 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c const char *pubKeyStr = (pubKeyData == NULL)? NULL : (const char *)pubKeyData->data; switch (type) { case CRYPTO_PEM: - ret = ctx->convertPemKey((HcfAsyKeyGenerator *)ctx, NULL, pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx); + ret = ctx->convertPemKey == NULL + ? CRYPTO_INVALID_PARAMS + : ctx->convertPemKey((HcfAsyKeyGenerator *)ctx, NULL, pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx); break; case CRYPTO_DER: - ret = ctx->convertKey((HcfAsyKeyGenerator *)ctx, NULL, - (HcfBlob *)pubKeyData, (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); + ret = ctx->convertKey == NULL ? CRYPTO_INVALID_PARAMS + : ctx->convertKey((HcfAsyKeyGenerator *)ctx, NULL, (HcfBlob *)pubKeyData, + (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); break; default: return CRYPTO_INVALID_PARAMS; @@ -106,7 +109,7 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c const char *OH_CryptoAsymKeyGenerator_GetAlgoName(OH_CryptoAsymKeyGenerator *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || c(tx->getAlgoName == NULL)) { return NULL; } return ctx->getAlgoName((HcfAsyKeyGenerator *)ctx); @@ -114,7 +117,7 @@ const char *OH_CryptoAsymKeyGenerator_GetAlgoName(OH_CryptoAsymKeyGenerator *ctx void OH_CryptoAsymKeyGenerator_Destroy(OH_CryptoAsymKeyGenerator *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->base.destroy == NULL)) { return; } ctx->base.destroy((HcfObjectBase *)ctx); @@ -122,7 +125,7 @@ void OH_CryptoAsymKeyGenerator_Destroy(OH_CryptoAsymKeyGenerator *ctx) void OH_CryptoKeyPair_Destroy(OH_CryptoKeyPair *keyCtx) { - if (keyCtx == NULL) { + if ((keyCtx == NULL) || (keyCtx->base.destroy == NULL)) { return; } keyCtx->base.destroy((HcfObjectBase *)keyCtx); @@ -146,6 +149,9 @@ OH_Crypto_ErrCode OH_CryptoPubKey_Encode(OH_CryptoPubKey *key, Crypto_EncodingTy char *pemStr = NULL; switch (type) { case CRYPTO_PEM: + if (key->base.getEncodedPem == NULL) { + return CRYPTO_INVALID_PARAMS; + } ret = key->base.getEncodedPem((HcfKey *)key, encodingStandard, &pemStr); if (ret != HCF_SUCCESS) { break; @@ -155,10 +161,13 @@ OH_Crypto_ErrCode OH_CryptoPubKey_Encode(OH_CryptoPubKey *key, Crypto_EncodingTy break; case CRYPTO_DER: if (encodingStandard != NULL) { - ret = key->getEncodedDer((HcfPubKey *)key, encodingStandard, (HcfBlob *)out); + ret = key->getEncodedDer == NULL + ? CRYPTO_INVALID_PARAMS + : key->getEncodedDer((HcfPubKey *)key, encodingStandard, (HcfBlob *)out); break; } else { - ret = key->base.getEncoded((HcfKey *)key, (HcfBlob *)out); + ret = key->base.getEncoded == NULL ? CRYPTO_INVALID_PARAMS + : key->base.getEncoded((HcfKey *)key, (HcfBlob *)out); break; } default: @@ -186,7 +195,9 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P ret = HCF_ERR_MALLOC; break; } - ret = key->getAsyKeySpecInt((HcfPubKey *)key, (AsyKeySpecItem)item, returnInt); + ret = key->getAsyKeySpecInt == NULL + ? CRYPTO_INVALID_PARAMS + : key->getAsyKeySpecInt((HcfPubKey *)key, (AsyKeySpecItem)item, returnInt); if (ret != HCF_SUCCESS) { HcfFree(returnInt); break; @@ -196,7 +207,9 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P break; case CRYPTO_ECC_FIELD_TYPE_STR: case CRYPTO_ECC_CURVE_NAME_STR: - ret = key->getAsyKeySpecString((HcfPubKey *)key, (AsyKeySpecItem)item, &returnStr); + ret = key->getAsyKeySpecString == NULL + ? CRYPTO_INVALID_PARAMS + : key->getAsyKeySpecString((HcfPubKey *)key, (AsyKeySpecItem)item, &returnStr); if (ret != HCF_SUCCESS) { break; } @@ -204,7 +217,9 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P value->len = strlen(returnStr); break; default: - ret = key->getAsyKeySpecBigInteger((HcfPubKey *)key, + ret = key->getAsyKeySpecBigInteger == NULL + ? CRYPTO_INVALID_PARAMS + : key->getAsyKeySpecBigInteger((HcfPubKey *)key, (AsyKeySpecItem)item, &bigIntValue); if (ret != HCF_SUCCESS) { break; diff --git a/frameworks/native/src/digest.c b/frameworks/native/src/digest.c index b8d9ab2..8d0a6c6 100644 --- a/frameworks/native/src/digest.c +++ b/frameworks/native/src/digest.c @@ -44,7 +44,7 @@ OH_Crypto_ErrCode OH_CryptoDigest_Create(const char *algoName, OH_CryptoDigest * OH_Crypto_ErrCode OH_CryptoDigest_Update(OH_CryptoDigest *ctx, Crypto_DataBlob *in) { - if ((ctx == NULL) || (in == NULL)) { + if ((ctx == NULL) || (ctx->update == NULL) || (in == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->update((HcfMd *)ctx, (HcfBlob *)in); @@ -53,7 +53,7 @@ OH_Crypto_ErrCode OH_CryptoDigest_Update(OH_CryptoDigest *ctx, Crypto_DataBlob * OH_Crypto_ErrCode OH_CryptoDigest_Final(OH_CryptoDigest *ctx, Crypto_DataBlob *out) { - if ((ctx == NULL) || (out == NULL)) { + if ((ctx == NULL) || (ctx->doFinal == NULL) || (out == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->doFinal((HcfMd *)ctx, (HcfBlob *)out); @@ -62,7 +62,7 @@ OH_Crypto_ErrCode OH_CryptoDigest_Final(OH_CryptoDigest *ctx, Crypto_DataBlob *o uint32_t OH_CryptoDigest_GetLength(OH_CryptoDigest *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->getMdLength == NULL)) { return CRYPTO_INVALID_PARAMS; } return ctx->getMdLength((HcfMd *)ctx); @@ -70,7 +70,7 @@ uint32_t OH_CryptoDigest_GetLength(OH_CryptoDigest *ctx) const char *OH_CryptoDigest_GetAlgoName(OH_CryptoDigest *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->getAlgoName == NULL)) { return NULL; } return ctx->getAlgoName((HcfMd *)ctx); @@ -78,7 +78,7 @@ const char *OH_CryptoDigest_GetAlgoName(OH_CryptoDigest *ctx) void OH_DigestCrypto_Destroy(OH_CryptoDigest *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->base.destroy == NULL)) { return; } ctx->base.destroy((HcfObjectBase *)ctx); diff --git a/frameworks/native/src/signature.c b/frameworks/native/src/signature.c index 060e78a..ebcd1b8 100644 --- a/frameworks/native/src/signature.c +++ b/frameworks/native/src/signature.c @@ -57,7 +57,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_Create(const char *algoName, OH_CryptoVerify * OH_Crypto_ErrCode OH_CryptoVerify_Init(OH_CryptoVerify *ctx, OH_CryptoPubKey *pubKey) { - if ((ctx == NULL) || (pubKey == NULL)) { + if ((ctx == NULL) || (ctx->init == NULL) || (pubKey == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->init((HcfVerify *)ctx, NULL, (HcfPubKey *)pubKey); @@ -66,7 +66,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_Init(OH_CryptoVerify *ctx, OH_CryptoPubKey *pu OH_Crypto_ErrCode OH_CryptoVerify_Update(OH_CryptoVerify *ctx, Crypto_DataBlob *in) { - if ((ctx == NULL) || (in == NULL)) { + if ((ctx == NULL) || (ctx->update == NULL) || (in == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->update((HcfVerify *)ctx, (HcfBlob *)in); @@ -75,7 +75,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_Update(OH_CryptoVerify *ctx, Crypto_DataBlob * bool OH_CryptoVerify_Final(OH_CryptoVerify *ctx, Crypto_DataBlob *in, Crypto_DataBlob *signData) { - if ((ctx == NULL) || (signData == NULL)) { + if ((ctx == NULL) || (ctx->verify == NULL) || (signData == NULL)) { return false; } bool ret = ctx->verify((HcfVerify *)ctx, (HcfBlob *)in, (HcfBlob *)signData); @@ -89,7 +89,7 @@ bool OH_CryptoVerify_Final(OH_CryptoVerify *ctx, Crypto_DataBlob *in, Crypto_Dat OH_Crypto_ErrCode OH_CryptoVerify_Recover(OH_CryptoVerify *ctx, Crypto_DataBlob *signData, Crypto_DataBlob *rawSignData) { - if ((ctx == NULL) || (signData == NULL) || (rawSignData == NULL)) { + if ((ctx == NULL) || (ctx->recover == NULL) || (signData == NULL) || (rawSignData == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->recover((HcfVerify *)ctx, (HcfBlob *)signData, (HcfBlob *)rawSignData); @@ -98,7 +98,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_Recover(OH_CryptoVerify *ctx, Crypto_DataBlob const char *OH_CryptoVerify_GetAlgoName(OH_CryptoVerify *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->getAlgoName == NULL)) { return NULL; } return ctx->getAlgoName((HcfVerify *)ctx); @@ -114,7 +114,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_SetParam(OH_CryptoVerify *ctx, CryptoSignature switch (type) { case CRYPTO_PSS_SALT_LEN_INT: case CRYPTO_PSS_TRAILER_FIELD_INT: - if (value->len != sizeof(int32_t)) { + if (value->len != sizeof(int32_t) || ctx->setVerifySpecInt = NULL) { ret = HCF_INVALID_PARAMS; break; } @@ -124,6 +124,10 @@ OH_Crypto_ErrCode OH_CryptoVerify_SetParam(OH_CryptoVerify *ctx, CryptoSignature case CRYPTO_PSS_MGF1_NAME_STR: case CRYPTO_PSS_MGF_NAME_STR: case CRYPTO_PSS_MD_NAME_STR: + if (ctx->setVerifySpecUint8Array == NULL) { + ret = HCF_INVALID_PARAMS; + break; + } ret = ctx->setVerifySpecUint8Array((HcfVerify *)ctx, (SignSpecItem)type, *((HcfBlob *)value)); break; default: @@ -145,6 +149,10 @@ OH_Crypto_ErrCode OH_CryptoVerify_GetParam(OH_CryptoVerify *ctx, CryptoSignature case CRYPTO_PSS_SALT_LEN_INT: case CRYPTO_PSS_TRAILER_FIELD_INT: case CRYPTO_SM2_USER_ID_DATABLOB: + if (ctx->getVerifySpecInt == NULL) { + ret = HCF_INVALID_PARAMS; + break; + } returnInt = (int32_t *)HcfMalloc(sizeof(int32_t), 0); if (returnInt == NULL) { return CRYPTO_MEMORY_ERROR; @@ -160,6 +168,10 @@ OH_Crypto_ErrCode OH_CryptoVerify_GetParam(OH_CryptoVerify *ctx, CryptoSignature case CRYPTO_PSS_MD_NAME_STR: case CRYPTO_PSS_MGF_NAME_STR: case CRYPTO_PSS_MGF1_NAME_STR: + if (ctx->getVerifySpecString == NULL) { + ret = HCF_INVALID_PARAMS; + break; + } ret = ctx->getVerifySpecString((HcfVerify *)ctx, (SignSpecItem)type, &returnStr); if (ret != HCF_SUCCESS) { break; @@ -176,7 +188,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_GetParam(OH_CryptoVerify *ctx, CryptoSignature void OH_CryptoVerify_Destroy(OH_CryptoVerify *ctx) { - if (ctx == NULL) { + if (ctx == NULL || ctx->base.destroy == NULL) { return; } ctx->base.destroy((HcfObjectBase *)ctx); diff --git a/frameworks/native/src/sym_cipher.c b/frameworks/native/src/sym_cipher.c index 615d554..ac7f75f 100644 --- a/frameworks/native/src/sym_cipher.c +++ b/frameworks/native/src/sym_cipher.c @@ -113,7 +113,7 @@ OH_Crypto_ErrCode OH_CryptoSymCipher_Create(const char *algoName, OH_CryptoSymCi OH_Crypto_ErrCode OH_CryptoSymCipher_Init(OH_CryptoSymCipher *ctx, Crypto_CipherMode mod, OH_CryptoSymKey *key, OH_CryptoSymCipherParams *params) { - if ((ctx == NULL) || (key == NULL)) { + if ((ctx == NULL) || (ctx->init == NULL) || (key == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->init((HcfCipher *)ctx, (enum HcfCryptoMode)mod, (HcfKey *)key, (HcfParamsSpec *)params); @@ -122,7 +122,7 @@ OH_Crypto_ErrCode OH_CryptoSymCipher_Init(OH_CryptoSymCipher *ctx, Crypto_Cipher OH_Crypto_ErrCode OH_CryptoSymCipher_Update(OH_CryptoSymCipher *ctx, Crypto_DataBlob *in, Crypto_DataBlob *out) { - if ((ctx == NULL) || (in == NULL) || (out == NULL)) { + if ((ctx == NULL) || (ctx->update == NULL) || (in == NULL) || (out == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->update((HcfCipher *)ctx, (HcfBlob *)in, (HcfBlob *)out); @@ -131,7 +131,7 @@ OH_Crypto_ErrCode OH_CryptoSymCipher_Update(OH_CryptoSymCipher *ctx, Crypto_Data OH_Crypto_ErrCode OH_CryptoSymCipher_Final(OH_CryptoSymCipher *ctx, Crypto_DataBlob *in, Crypto_DataBlob *out) { - if ((ctx == NULL) || (out == NULL)) { + if ((ctx == NULL) || (ctx->doFinal == NULL) || (out == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->doFinal((HcfCipher *)ctx, (HcfBlob *)in, (HcfBlob *)out); @@ -140,7 +140,7 @@ OH_Crypto_ErrCode OH_CryptoSymCipher_Final(OH_CryptoSymCipher *ctx, Crypto_DataB const char *OH_CryptoSymCipher_GetAlgoName(OH_CryptoSymCipher *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->getAlgorithm == NULL)) { return NULL; } return ctx->getAlgorithm((HcfCipher *)ctx); @@ -148,7 +148,7 @@ const char *OH_CryptoSymCipher_GetAlgoName(OH_CryptoSymCipher *ctx) void OH_CryptoSymCipher_Destroy(OH_CryptoSymCipher *ctx) { - if (ctx == NULL) { + if ((ctx == NULL) || (ctx->base.destroy == NULL)) { return; } ctx->base.destroy((HcfObjectBase *)ctx); diff --git a/frameworks/native/src/sym_key.c b/frameworks/native/src/sym_key.c index df250d8..d5d44c9 100644 --- a/frameworks/native/src/sym_key.c +++ b/frameworks/native/src/sym_key.c @@ -53,7 +53,7 @@ OH_Crypto_ErrCode OH_CryptoSymKeyGenerator_Create(const char *algoName, OH_Crypt OH_Crypto_ErrCode OH_CryptoSymKeyGenerator_Generate(OH_CryptoSymKeyGenerator *ctx, OH_CryptoSymKey **keyCtx) { - if ((ctx == NULL) || (keyCtx == NULL)) { + if ((ctx == NULL) || (ctx->generateSymKey == NULL) || (keyCtx == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->generateSymKey((HcfSymKeyGenerator *)ctx, (HcfSymKey **)keyCtx); @@ -63,7 +63,7 @@ OH_Crypto_ErrCode OH_CryptoSymKeyGenerator_Generate(OH_CryptoSymKeyGenerator *ct OH_Crypto_ErrCode OH_CryptoSymKeyGenerator_Convert(OH_CryptoSymKeyGenerator *ctx, const Crypto_DataBlob *keyData, OH_CryptoSymKey **keyCtx) { - if ((ctx == NULL) || (keyData == NULL) || (keyCtx == NULL)) { + if ((ctx == NULL) || (ctx->convertSymKey == NULL) || (keyData == NULL) || (keyCtx == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = ctx->convertSymKey((HcfSymKeyGenerator *)ctx, (HcfBlob *)keyData, (HcfSymKey **)keyCtx); @@ -72,7 +72,7 @@ OH_Crypto_ErrCode OH_CryptoSymKeyGenerator_Convert(OH_CryptoSymKeyGenerator *ctx const char *OH_CryptoSymKeyGenerator_GetAlgoName(OH_CryptoSymKeyGenerator *ctx) { - if (ctx == NULL) { + if (ctx == NULL || (ctx->getAlgoName == NULL)) { return NULL; } return ctx->getAlgoName((HcfSymKeyGenerator *)ctx); @@ -80,7 +80,7 @@ const char *OH_CryptoSymKeyGenerator_GetAlgoName(OH_CryptoSymKeyGenerator *ctx) void OH_CryptoSymKeyGenerator_Destroy(OH_CryptoSymKeyGenerator *ctx) { - if (ctx == NULL) { + if (ctx == NULL || (ctx->base.destroy == NULL)) { return; } ctx->base.destroy((HcfObjectBase *)ctx); @@ -88,7 +88,7 @@ void OH_CryptoSymKeyGenerator_Destroy(OH_CryptoSymKeyGenerator *ctx) const char *OH_CryptoSymKey_GetAlgoName(OH_CryptoSymKey *keyCtx) { - if (keyCtx == NULL) { + if (keyCtx == NUL || (keyCtx->key.getAlgorithm == NULL)L) { return NULL; } return keyCtx->key.getAlgorithm((HcfKey *)keyCtx); @@ -96,7 +96,7 @@ const char *OH_CryptoSymKey_GetAlgoName(OH_CryptoSymKey *keyCtx) OH_Crypto_ErrCode OH_CryptoSymKey_GetKeyData(OH_CryptoSymKey *keyCtx, Crypto_DataBlob *out) { - if ((keyCtx == NULL) || (out == NULL)) { + if ((keyCtx == NULL) || (keyCtx->key.getEncoded == NULL) || (out == NULL)) { return CRYPTO_INVALID_PARAMS; } HcfResult ret = keyCtx->key.getEncoded((HcfKey *)keyCtx, (HcfBlob *)out); @@ -105,7 +105,7 @@ OH_Crypto_ErrCode OH_CryptoSymKey_GetKeyData(OH_CryptoSymKey *keyCtx, Crypto_Dat void OH_CryptoSymKey_Destroy(OH_CryptoSymKey *keyCtx) { - if (keyCtx == NULL) { + if ((keyCtx == NULL) || (keyCtx->key.base.destroy == NULL)) { return; } keyCtx->key.base.destroy((HcfObjectBase *)keyCtx); -- Gitee From 394f9f4e5d089b1fa5395cfe01cd93f088c7bdfe Mon Sep 17 00:00:00 2001 From: lanming Date: Sun, 25 Aug 2024 15:39:32 +0800 Subject: [PATCH 15/32] fix issue Signed-off-by: lanming --- .../openssl_plugin/common/src/openssl_common.c | 1 - .../crypto_operation/kdf/src/hkdf_openssl.c | 6 ++++++ .../signature/src/sm2_openssl.c | 17 ++++------------- .../src/alg_25519_asy_key_generator_openssl.c | 15 ++++++++------- 4 files changed, 18 insertions(+), 21 deletions(-) diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 83d82af..b054a34 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -539,7 +539,6 @@ HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret) } if (OpensslEvpPkeyDerive(ctx, secretData, &maxLen) != HCF_OPENSSL_SUCCESS) { - (void)memset_s(secretData, maxLen, 0, maxLen); LOGD("[error] Evp key derive failed!"); HcfPrintOpensslError(); HcfFree(secretData); diff --git a/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c b/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c index a0ca0b9..4f3f2b5 100644 --- a/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/kdf/src/hkdf_openssl.c @@ -202,6 +202,12 @@ static HcfResult InitHkdfData(OpensslHkdfSpiImpl *self, HcfHkdfParamsSpec *param LOGE("malloc info failed!"); break; } + data->out = (unsigned char *)HcfMalloc(params->output.len, 0); + if (data->out == NULL) { + LOGE("malloc out failed!"); + break; + } + data->outLen = params->output.len; self->kdfData = data; return HCF_SUCCESS; } while (0); diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c index 897bca3..458eb19 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c @@ -141,11 +141,7 @@ static HcfResult SetUserIdFromBlob(HcfBlob userId, EVP_MD_CTX *mdCtx) LOGE("Failed to allocate openssl userId data memory"); return HCF_ERR_MALLOC; } - if (memcpy_s(opensslUserId, userId.len, userId.data, userId.len) != EOK) { - LOGE("memcpy opensslUserId failed."); - HcfFree(opensslUserId); - return HCF_ERR_MALLOC; - } + (void)memcpy_s(opensslUserId, userId.len, userId.data, userId.len); if (OpensslEvpPkeyCtxSet1Id(pKeyCtx, (const void*)opensslUserId, userId.len) != HCF_OPENSSL_SUCCESS) { LOGD("[error] Set sm2 user id fail."); @@ -300,21 +296,16 @@ static HcfResult EngineSignDoFinal(HcfSignSpi *self, HcfBlob *data, HcfBlob *ret LOGE("Failed to allocate outData memory!"); return HCF_ERR_MALLOC; } - size_t actualLen = maxLen; - if (OpensslEvpDigestSignFinal(impl->mdCtx, outData, &actualLen) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpDigestSignFinal(impl->mdCtx, outData, &maxLen) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); LOGD("[error] EVP_DigestSignFinal failed."); HcfFree(outData); return HCF_ERR_CRYPTO_OPERATION; } - if (actualLen > maxLen) { - LOGD("[error] signature data too long."); - HcfFree(outData); - return HCF_ERR_CRYPTO_OPERATION; - } returnSignatureData->data = outData; - returnSignatureData->len = (uint32_t)actualLen; + returnSignatureData->len = (uint32_t)maxLen; return HCF_SUCCESS; } 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 467eed4..52d8a23 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 @@ -69,19 +69,20 @@ static void DestroyAlg25519KeyGeneratorSpiImpl(HcfObjectBase *self) { if ((self == NULL) || (self->getClass() == NULL)) { LOGE("Invalid input parameter."); - return; + return; } - if (strcmp(obj->getClass(), GetEd25519KeyGeneratorSpiClass()) != 0 && ) { - return true; + if (strcmp(self->getClass(), GetX25519KeyGeneratorSpiClass()) == 0) { + HcfFree(self); + return; } - if (!HcfIsClassMatch(self, GetEd25519KeyGeneratorSpiClass()) && - !HcfIsClassMatch(self, GetX25519KeyGeneratorSpiClass())) { - LOGE("Invalid class of self."); + if (strcmp(self->getClass(), GetEd25519KeyGeneratorSpiClass()) == 0) { + HcfFree(self); return; } - HcfFree(self); + LOGE("Invalid input parameter."); + return; } static void DestroyAlg25519PubKey(HcfObjectBase *self) -- Gitee From 49f015b0b5996f59e5b1b44c76ed45410763a78d Mon Sep 17 00:00:00 2001 From: liwei3013 Date: Sat, 24 Aug 2024 11:39:03 +0800 Subject: [PATCH 16/32] =?UTF-8?q?issue=20=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- .../crypto_operation/cipher/src/cipher_aes_openssl.c | 1 + .../crypto_operation/cipher/src/cipher_rsa_openssl.c | 2 -- .../crypto_operation/cipher/src/cipher_sm4_openssl.c | 1 + 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index 8720c59..51ae9a8 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -350,6 +350,7 @@ static HcfResult InitCipherData(HcfCipherGeneratorSpi *self, enum HcfCryptoMode ret = InitAadAndTagFromGcmParams(opMode, (HcfGcmParamsSpec *)params, *cipherData); break; default: + ret = HCF_NOT_SUPPORT; break; } if (ret != HCF_SUCCESS) { diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c index 13aaecc..1534c7e 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c @@ -414,7 +414,6 @@ static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfB LOGD("[error] GetOutLen fail."); return HCF_ERR_CRYPTO_OPERATION; } - LOGD("ouput data len is %zu.", output->len); output->data = (uint8_t *)HcfMalloc(sizeof(uint8_t) * output->len, 0); if (output->data == NULL) { @@ -517,6 +516,5 @@ HcfResult HcfCipherRsaCipherSpiCreate(CipherAttr *params, HcfCipherGeneratorSpi returnImpl->super.base.getClass = EngineGetClass; returnImpl->initFlag = UNINITIALIZED; *generator = (HcfCipherGeneratorSpi *)returnImpl; - LOGD("Rsa Cipher create success."); return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c index 750f2ac..f895a98 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c @@ -246,6 +246,7 @@ static HcfResult InitCipherData(HcfCipherGeneratorSpi* self, enum HcfCryptoMode ret = HCF_NOT_SUPPORT; break; default: + ret = HCF_NOT_SUPPORT; break; } if (ret != HCF_SUCCESS) { -- Gitee From 9efa34512a67af359a1864f8bb78b0ead771838d Mon Sep 17 00:00:00 2001 From: liwei3013 Date: Sat, 24 Aug 2024 20:22:52 +0800 Subject: [PATCH 17/32] =?UTF-8?q?=E6=95=8F=E6=84=9F=E4=BF=A1=E6=81=AF?= =?UTF-8?q?=E6=93=A6=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp | 4 ++-- frameworks/js/napi/crypto/src/napi_cipher.cpp | 8 ++++---- frameworks/js/napi/crypto/src/napi_key.cpp | 2 +- frameworks/js/napi/crypto/src/napi_key_agreement.cpp | 2 +- frameworks/js/napi/crypto/src/napi_pri_key.cpp | 4 ++-- frameworks/js/napi/crypto/src/napi_rand.cpp | 8 ++++---- frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp | 2 +- .../crypto_operation/cipher/src/cipher_3des_openssl.c | 4 ++-- .../crypto_operation/cipher/src/cipher_aes_openssl.c | 6 +++--- .../crypto_operation/cipher/src/cipher_sm4_openssl.c | 4 ++-- 10 files changed, 22 insertions(+), 22 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 a3aff13..b24b8ee 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -132,7 +132,7 @@ static void FreeConvertKeyCtx(napi_env env, ConvertKeyCtx *ctx) HcfBlobDataFree(ctx->pubKey); HcfFree(ctx->pubKey); - HcfBlobDataFree(ctx->priKey); + HcfBlobDataClearAndFree(ctx->priKey); HcfFree(ctx->priKey); HcfFree(ctx); } @@ -761,7 +761,7 @@ static void HcfFreePubKeyAndPriKey(HcfBlob *pubKey, HcfBlob *priKey) { HcfBlobDataFree(pubKey); HcfFree(pubKey); - HcfBlobDataFree(priKey); + HcfBlobDataClearAndFree(priKey); HcfFree(priKey); } diff --git a/frameworks/js/napi/crypto/src/napi_cipher.cpp b/frameworks/js/napi/crypto/src/napi_cipher.cpp index 1b7a977..da2fdc3 100644 --- a/frameworks/js/napi/crypto/src/napi_cipher.cpp +++ b/frameworks/js/napi/crypto/src/napi_cipher.cpp @@ -648,7 +648,7 @@ napi_value NapiCipher::JsCipherUpdateSync(napi_env env, napi_callback_info info) } HcfBlob output = { .data = nullptr, .len = 0 }; errCode = cipher->update(cipher, &input, &output); - HcfFree(input.data); + HcfBlobDataClearAndFree(&input); if (errCode != HCF_SUCCESS) { LOGE("failed to update!"); napi_throw(env, GenerateBusinessError(env, errCode, "update fail!")); @@ -657,7 +657,7 @@ napi_value NapiCipher::JsCipherUpdateSync(napi_env env, napi_callback_info info) napi_value instance = nullptr; errCode = ConvertDataBlobToNapiValue(env, &output, &instance); - HcfFree(output.data); + HcfBlobDataClearAndFree(&output); if (errCode != HCF_SUCCESS) { LOGE("cipher update convert dataBlob to napi_value failed!"); napi_throw(env, GenerateBusinessError(env, errCode, "cipher update convert dataBlob to napi_value failed!")); @@ -721,7 +721,7 @@ napi_value NapiCipher::JsCipherDoFinalSync(napi_env env, napi_callback_info info } HcfBlob output = { .data = nullptr, .len = 0 }; HcfResult res = cipher->doFinal(cipher, input, &output); - HcfBlobDataFree(input); + HcfBlobDataClearAndFree(input); if (res != HCF_SUCCESS) { LOGE("failed to do final!"); napi_throw(env, GenerateBusinessError(env, res, "do final fail!")); @@ -730,7 +730,7 @@ napi_value NapiCipher::JsCipherDoFinalSync(napi_env env, napi_callback_info info napi_value instance = nullptr; res = ConvertDataBlobToNapiValue(env, &output, &instance); - HcfFree(output.data); + HcfBlobDataClearAndFree(&output) if (res != HCF_SUCCESS) { LOGE("cipher convert dataBlob to napi_value failed!"); napi_throw(env, GenerateBusinessError(env, res, "cipher convert dataBlob to napi_value failed!")); diff --git a/frameworks/js/napi/crypto/src/napi_key.cpp b/frameworks/js/napi/crypto/src/napi_key.cpp index deb23b3..f6a816d 100644 --- a/frameworks/js/napi/crypto/src/napi_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_key.cpp @@ -113,7 +113,7 @@ napi_value NapiKey::JsGetEncoded(napi_env env, napi_callback_info info) return nullptr; } napi_value instance = ConvertBlobToNapiValue(env, &blob); - HcfBlobDataFree(&blob); + HcfBlobDataClearAndFree(&blob); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp index 12aa712..0e6ff2d 100644 --- a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp +++ b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp @@ -348,7 +348,7 @@ napi_value NapiKeyAgreement::JsGenerateSecretSync(napi_env env, napi_callback_in napi_value instance = nullptr; ret = ConvertDataBlobToNapiValue(env, &returnSecret, &instance); - HcfBlobDataFree(&returnSecret); + HcfBlobDataClearAndFree(&returnSecret); if (ret != HCF_SUCCESS) { LOGE("key agreement convert dataBlob to napi_value failed!"); napi_throw(env, GenerateBusinessError(env, ret, "key agreement convert dataBlob to napi_value failed!")); diff --git a/frameworks/js/napi/crypto/src/napi_pri_key.cpp b/frameworks/js/napi/crypto/src/napi_pri_key.cpp index 8f2a046..2593292 100644 --- a/frameworks/js/napi/crypto/src/napi_pri_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pri_key.cpp @@ -96,7 +96,7 @@ napi_value NapiPriKey::JsGetEncoded(napi_env env, napi_callback_info info) LOGE("covert blob to napi value failed."); return nullptr; } - HcfBlobDataFree(&returnBlob); + HcfBlobDataClearAndFree(&returnBlob); return instance; } @@ -316,7 +316,7 @@ napi_value NapiPriKey::JsGetEncodedDer(napi_env env, napi_callback_info info) LOGE("covert blob to napi value failed."); return nullptr; } - HcfBlobDataFree(&returnBlob); + HcfBlobDataClearAndFree(&returnBlob); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_rand.cpp b/frameworks/js/napi/crypto/src/napi_rand.cpp index 212a7c5..7d72983 100644 --- a/frameworks/js/napi/crypto/src/napi_rand.cpp +++ b/frameworks/js/napi/crypto/src/napi_rand.cpp @@ -315,7 +315,7 @@ napi_value NapiRand::JsSetSeed(napi_env env, napi_callback_info info) } napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiRand)); if (status != napi_ok || napiRand == nullptr) { - HcfBlobDataFree(seedBlob); + HcfBlobDataClearAndFree(seedBlob); HcfFree(seedBlob); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap NapiRand obj!")); LOGE("failed to unwrap NapiRand obj!"); @@ -323,7 +323,7 @@ napi_value NapiRand::JsSetSeed(napi_env env, napi_callback_info info) } HcfRand *rand = napiRand->GetRand(); if (rand == nullptr) { - HcfBlobDataFree(seedBlob); + HcfBlobDataClearAndFree(seedBlob); HcfFree(seedBlob); napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "fail to get rand obj!")); LOGE("fail to get rand obj!"); @@ -331,13 +331,13 @@ napi_value NapiRand::JsSetSeed(napi_env env, napi_callback_info info) } HcfResult res = rand->setSeed(rand, seedBlob); if (res != HCF_SUCCESS) { - HcfBlobDataFree(seedBlob); + HcfBlobDataClearAndFree(seedBlob); HcfFree(seedBlob); napi_throw(env, GenerateBusinessError(env, res, "set seed failed.")); LOGD("[error] set seed failed."); return nullptr; } - HcfBlobDataFree(seedBlob); + HcfBlobDataClearAndFree(seedBlob); HcfFree(seedBlob); return thisVar; } diff --git a/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp index 1b51cd2..690782d 100644 --- a/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp @@ -477,7 +477,7 @@ napi_value NapiSymKeyGenerator::JsConvertKeySync(napi_env env, napi_callback_inf HcfSymKey *key = nullptr; HcfResult ret = generator->convertSymKey(generator, keyMaterial, &key); - HcfBlobDataFree(keyMaterial); + HcfBlobDataClearAndFree(keyMaterial); HcfFree(keyMaterial); if (ret != HCF_SUCCESS) { napi_throw(env, GenerateBusinessError(env, ret, "convertSymKey key failed!")); diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c index 01bf8f2..b8c1c45 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_3des_openssl.c @@ -192,7 +192,7 @@ static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBl res = HCF_SUCCESS; clearup: if (res != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); FreeCipherData(&(cipherImpl->cipherData)); } else { FreeRedundantOutput(output); @@ -253,7 +253,7 @@ static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfB } clearup: if (res != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); } else { FreeRedundantOutput(output); } diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index 51ae9a8..9013131 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -533,7 +533,7 @@ static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBl ret = AeadUpdate(data, cipherImpl->attr.mode, input, output); } if (ret != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); FreeCipherData(&(cipherImpl->cipherData)); } data->aead = false; @@ -597,7 +597,7 @@ static HcfResult CcmDecryptDoFinal(HcfBlob *output, bool isUpdateInput) return HCF_SUCCESS; } if (output->data != NULL) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); } return HCF_SUCCESS; } @@ -768,7 +768,7 @@ static HcfResult EngineDoFinal(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfB FreeCipherData(&(cipherImpl->cipherData)); if (ret != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); } FreeRedundantOutput(output); return ret; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c index f895a98..7f4114b 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c @@ -460,7 +460,7 @@ static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBl ret = AeadUpdate(data, cipherImpl->attr.mode, input, output); } if (ret != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); FreeCipherData(&(cipherImpl->cipherData)); } data->aead = false; @@ -625,7 +625,7 @@ static HcfResult EngineDoFinal(HcfCipherGeneratorSpi* self, HcfBlob* input, HcfB FreeCipherData(&(cipherImpl->cipherData)); if (ret != HCF_SUCCESS) { - HcfBlobDataFree(output); + HcfBlobDataClearAndFree(output); } FreeRedundantOutput(output); return ret; -- Gitee From 44e06bffce3a9f4c4fc7d194133da364020479fc Mon Sep 17 00:00:00 2001 From: zxz*3 Date: Sat, 24 Aug 2024 21:42:19 +0800 Subject: [PATCH 18/32] fix issue Signed-off-by: zxz*3 --- common/src/asy_key_params.c | 4 ++-- common/src/hcf_parcel.c | 7 +++--- common/src/hcf_string.c | 10 ++++---- frameworks/crypto_operation/cipher.c | 2 +- frameworks/crypto_operation/kdf.c | 8 +++---- .../crypto/src/napi_asy_key_generator.cpp | 9 ++++--- .../src/napi_asy_key_spec_generator.cpp | 4 ++-- frameworks/js/napi/crypto/src/napi_kdf.cpp | 2 -- frameworks/js/napi/crypto/src/napi_mac.cpp | 3 --- frameworks/js/napi/crypto/src/napi_md.cpp | 3 --- frameworks/js/napi/crypto/src/napi_rand.cpp | 1 - frameworks/js/napi/crypto/src/napi_sign.cpp | 2 -- .../crypto/src/napi_sym_key_generator.cpp | 4 ++-- frameworks/js/napi/crypto/src/napi_utils.cpp | 3 --- frameworks/js/napi/crypto/src/napi_verify.cpp | 7 ++++-- frameworks/native/src/crypto_common.c | 2 +- frameworks/native/src/signature.c | 8 +++---- .../common/src/ecc_openssl_common.c | 6 ++--- .../common/src/openssl_adapter.c | 14 +++++------ .../common/src/openssl_common.c | 2 +- .../cipher/src/cipher_aes_openssl.c | 4 ++-- .../cipher/src/cipher_rsa_openssl.c | 4 ++-- .../cipher/src/cipher_sm4_openssl.c | 6 ++--- .../crypto_operation/md/src/md_openssl.c | 8 +++++++ .../crypto_operation/rand/src/rand_openssl.c | 4 ++++ .../signature/src/signature_rsa_openssl.c | 10 +++----- .../src/alg_25519_asy_key_generator_openssl.c | 18 +++++++------- .../src/dh_asy_key_generator_openssl.c | 15 ++++++------ .../dh_common_param_spec_generator_openssl.c | 8 ++----- .../src/dsa_asy_key_generator_openssl.c | 12 +++++----- .../src/ecc_asy_key_generator_openssl.c | 24 ++++++++++++------- .../src/rsa_asy_key_generator_openssl.c | 13 +++++++--- .../src/sm2_asy_key_generator_openssl.c | 21 ++++++++-------- 33 files changed, 125 insertions(+), 123 deletions(-) diff --git a/common/src/asy_key_params.c b/common/src/asy_key_params.c index 403b420..a929b03 100644 --- a/common/src/asy_key_params.c +++ b/common/src/asy_key_params.c @@ -461,8 +461,8 @@ void FreeAsyKeySpec(HcfAsyKeyParamsSpec *spec) return; } HcfFreeParamsAsyKeySpec createFreeFunc = FindAsyKeySpecFreeAbility(spec); - if (createFreeFunc != NULL) { - return createFreeFunc(spec); + if (createFreeFunc != NULL) { + createFreeFunc(spec); } else { LOGE("create freeFunc failed."); } diff --git a/common/src/hcf_parcel.c b/common/src/hcf_parcel.c index 410f8e7..4f05927 100644 --- a/common/src/hcf_parcel.c +++ b/common/src/hcf_parcel.c @@ -46,7 +46,7 @@ void DeleteParcel(HcParcel *parcel) if (parcel->data != NULL) { HcfFree(parcel->data); - parcel->data = 0; + parcel->data = NULL; } parcel->length = 0; parcel->beginPos = 0; @@ -122,9 +122,8 @@ static void ParcelRecycle(HcParcel *parcel) uint32_t contentSize = parcel->endPos - parcel->beginPos; if (contentSize > 0) { - if (memmove_s(parcel->data, parcel->endPos - parcel->beginPos, - parcel->data + parcel->beginPos, parcel->endPos - parcel->beginPos) != EOK) { - } + (void)memmove_s(parcel->data, parcel->endPos - parcel->beginPos, + parcel->data + parcel->beginPos, parcel->endPos - parcel->beginPos); } parcel->beginPos = 0; parcel->endPos = contentSize; diff --git a/common/src/hcf_string.c b/common/src/hcf_string.c index 8d1b3d6..e7ed836 100644 --- a/common/src/hcf_string.c +++ b/common/src/hcf_string.c @@ -129,7 +129,7 @@ int StringFind(const HcString *self, char c, uint32_t begin) if (self == NULL) { return -1; } - + uint32_t p = begin; // because the return value is int // so the string length cannot bigger than MAX_INT uint32_t strLen = StringLength(self); @@ -138,11 +138,11 @@ int StringFind(const HcString *self, char c, uint32_t begin) } const char* curChar = StringGet(self); - while (begin < strLen) { - if (*(curChar + begin) == c) { - return begin; + while (p < strLen) { + if (*(curChar + p) == c) { + return p; } - ++begin; + ++p; } return -1; } diff --git a/frameworks/crypto_operation/cipher.c b/frameworks/crypto_operation/cipher.c index add67e4..aab445a 100644 --- a/frameworks/crypto_operation/cipher.c +++ b/frameworks/crypto_operation/cipher.c @@ -214,7 +214,7 @@ static HcfResult SetCipherSpecUint8Array(HcfCipher *self, CipherSpecItem item, H { // only implemented for OAEP_MGF1_PSRC_UINT8ARR // if pSource == NULL or len == 0, it means cleaning the pSource - if (self == NULL || pSource.len < 0) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } diff --git a/frameworks/crypto_operation/kdf.c b/frameworks/crypto_operation/kdf.c index 1b4ce47..1d45072 100644 --- a/frameworks/crypto_operation/kdf.c +++ b/frameworks/crypto_operation/kdf.c @@ -152,15 +152,15 @@ static void DestroyKdf(HcfObjectBase *self) HcfFree(impl); } -HcfResult HcfKdfCreate(const char *algoName, HcfKdf **returnObj) +HcfResult HcfKdfCreate(const char *transformation, HcfKdf **returnObj) { - if ((!HcfIsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) { + if ((!HcfIsStrValid(transformation, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) { LOGE("Invalid input params while creating kdf!"); return HCF_INVALID_PARAMS; } HcfKdfDeriveParams params = { 0 }; - if (ParseAndSetParameter(algoName, ¶ms, ParseKdfParams) != HCF_SUCCESS) { + if (ParseAndSetParameter(transformation, ¶ms, ParseKdfParams) != HCF_SUCCESS) { LOGE("Failed to parse params!"); return HCF_INVALID_PARAMS; } @@ -175,7 +175,7 @@ HcfResult HcfKdfCreate(const char *algoName, HcfKdf **returnObj) LOGE("Failed to allocate returnGenerator memory!"); return HCF_ERR_MALLOC; } - if (strcpy_s(returnGenerator->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) { + if (strcpy_s(returnGenerator->algoName, HCF_MAX_ALGO_NAME_LEN, transformation) != EOK) { LOGE("Failed to copy algoName!"); HcfFree(returnGenerator); return HCF_INVALID_PARAMS; 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 b24b8ee..5426604 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -156,7 +156,6 @@ static void FreeConvertPemKeyCtx(napi_env env, ConvertPemKeyCtx *ctx) ctx->pubKey = ""; ctx->priKey = ""; HcfFree(ctx); - ctx = nullptr; } static bool BuildGenKeyPairCtx(napi_env env, napi_callback_info info, GenKeyPairCtx *ctx) @@ -172,7 +171,7 @@ static bool BuildGenKeyPairCtx(napi_env env, napi_callback_info info, GenKeyPair } ctx->asyncType = isCallback(env, argv[0], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiAsyKeyGenerator *napiGenerator; + NapiAsyKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); @@ -287,7 +286,7 @@ static bool BuildConvertKeyCtx(napi_env env, napi_callback_info info, ConvertKey } ctx->asyncType = isCallback(env, argv[expectedArgc - 1], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiAsyKeyGenerator *napiGenerator; + NapiAsyKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); @@ -329,7 +328,7 @@ static bool BuildConvertPemKeyCtx(napi_env env, napi_callback_info info, Convert LOGE("wrong argument num. require %zu arguments. [Argc]: %zu!", expectedArgc, argc); return false; } - NapiAsyKeyGenerator *napiGenerator; + NapiAsyKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); @@ -863,7 +862,7 @@ napi_value NapiAsyKeyGenerator::JsConvertPemKeySync(napi_env env, napi_callback_ return nullptr; } - NapiAsyKeyGenerator *napiGenerator; + NapiAsyKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); diff --git a/frameworks/js/napi/crypto/src/napi_asy_key_spec_generator.cpp b/frameworks/js/napi/crypto/src/napi_asy_key_spec_generator.cpp index d0b470f..442c328 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_spec_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_spec_generator.cpp @@ -85,7 +85,7 @@ static bool BuildAsyKeyCtx(napi_env env, napi_callback_info info, AsyKeyCtx *ctx } ctx->asyncType = isCallback(env, argv[0], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiAsyKeyGeneratorBySpec *napiGenerator; + NapiAsyKeyGeneratorBySpec *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); @@ -111,7 +111,7 @@ static bool GetAsyKeyGenerator(napi_env env, napi_callback_info info, HcfAsyKeyG napi_value thisVar = nullptr; napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); - NapiAsyKeyGeneratorBySpec *napiGenerator; + NapiAsyKeyGeneratorBySpec *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap napi asyKeyGenerator obj."); diff --git a/frameworks/js/napi/crypto/src/napi_kdf.cpp b/frameworks/js/napi/crypto/src/napi_kdf.cpp index d7d8318..9a99858 100644 --- a/frameworks/js/napi/crypto/src/napi_kdf.cpp +++ b/frameworks/js/napi/crypto/src/napi_kdf.cpp @@ -595,7 +595,6 @@ napi_value NapiKdf::JsKdfGenerateSecretSync(napi_env env, napi_callback_info inf LOGE("KDF generateSecret failed!"); napi_throw(env, GenerateBusinessError(env, errCode, "KDF generateSecret failed!")); FreeKdfParamsSpec(paramsSpec); - paramsSpec = nullptr; return nullptr; } napi_value returnBlob = NewKdfJsGenSecretSyncWork(env, paramsSpec); @@ -635,7 +634,6 @@ napi_value NapiKdf::KdfConstructor(napi_env env, napi_callback_info info) napi_value NapiKdf::CreateJsKdf(napi_env env, napi_callback_info info) { - LOGD("Enter CreateKdf..."); size_t expectedArgc = ARGS_SIZE_ONE; size_t argc = expectedArgc; napi_value argv[ARGS_SIZE_ONE] = { nullptr }; diff --git a/frameworks/js/napi/crypto/src/napi_mac.cpp b/frameworks/js/napi/crypto/src/napi_mac.cpp index beecde6..1d91c44 100644 --- a/frameworks/js/napi/crypto/src/napi_mac.cpp +++ b/frameworks/js/napi/crypto/src/napi_mac.cpp @@ -87,7 +87,6 @@ static void FreeCryptoFwkCtx(napi_env env, MacCtx *context) context->errMsg = nullptr; context->mac = nullptr; HcfFree(context); - context = nullptr; } static void ReturnCallbackResult(napi_env env, MacCtx *context, napi_value result) @@ -642,7 +641,6 @@ static napi_value NapiWrapMac(napi_env env, napi_value instance, NapiMac *macNap if (status != napi_ok) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to wrap NapiMac obj!")); delete macNapiObj; - macNapiObj = nullptr; LOGE("failed to wrap NapiMac obj!"); return nullptr; } @@ -651,7 +649,6 @@ static napi_value NapiWrapMac(napi_env env, napi_value instance, NapiMac *macNap napi_value NapiMac::CreateMac(napi_env env, napi_callback_info info) { - LOGD("Enter CreateMac..."); size_t expectedArgc = ARGS_SIZE_ONE; size_t argc = expectedArgc; napi_value argv[ARGS_SIZE_ONE] = { nullptr }; diff --git a/frameworks/js/napi/crypto/src/napi_md.cpp b/frameworks/js/napi/crypto/src/napi_md.cpp index c2751c4..7ebe265 100644 --- a/frameworks/js/napi/crypto/src/napi_md.cpp +++ b/frameworks/js/napi/crypto/src/napi_md.cpp @@ -80,7 +80,6 @@ static void FreeCryptoFwkCtx(napi_env env, MdCtx *context) context->errMsg = nullptr; context->md = nullptr; HcfFree(context); - context = nullptr; } static void ReturnCallbackResult(napi_env env, MdCtx *context, napi_value result) @@ -481,7 +480,6 @@ static napi_value NapiWrapMd(napi_env env, napi_value instance, NapiMd *mdNapiOb if (status != napi_ok) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to wrap NapiMd obj!")); delete mdNapiObj; - mdNapiObj = nullptr; LOGE("failed to wrap NapiMd obj!"); return nullptr; } @@ -490,7 +488,6 @@ static napi_value NapiWrapMd(napi_env env, napi_value instance, NapiMd *mdNapiOb napi_value NapiMd::CreateMd(napi_env env, napi_callback_info info) { - LOGD("Enter CreateMd..."); size_t expectedArgc = ARGS_SIZE_ONE; size_t argc = expectedArgc; napi_value argv[ARGS_SIZE_ONE] = { nullptr }; diff --git a/frameworks/js/napi/crypto/src/napi_rand.cpp b/frameworks/js/napi/crypto/src/napi_rand.cpp index 7d72983..4b3c9bf 100644 --- a/frameworks/js/napi/crypto/src/napi_rand.cpp +++ b/frameworks/js/napi/crypto/src/napi_rand.cpp @@ -80,7 +80,6 @@ static void FreeCryptoFwkCtx(napi_env env, RandCtx *context) context->errMsg = nullptr; context->rand = nullptr; HcfFree(context); - context = nullptr; } static void ReturnCallbackResult(napi_env env, RandCtx *context, napi_value result) diff --git a/frameworks/js/napi/crypto/src/napi_sign.cpp b/frameworks/js/napi/crypto/src/napi_sign.cpp index 9f09012..213550c 100644 --- a/frameworks/js/napi/crypto/src/napi_sign.cpp +++ b/frameworks/js/napi/crypto/src/napi_sign.cpp @@ -767,7 +767,6 @@ static napi_value NapiWrapSign(napi_env env, napi_value instance, NapiSign *napi if (status != napi_ok) { LOGE("failed to wrap napiSign obj!"); delete napiSign; - napiSign = nullptr; return nullptr; } return instance; @@ -775,7 +774,6 @@ static napi_value NapiWrapSign(napi_env env, napi_value instance, NapiSign *napi napi_value NapiSign::CreateJsSign(napi_env env, napi_callback_info info) { - LOGD("Enter CreateJsSign..."); size_t expectedArgc = PARAMS_NUM_ONE; size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; diff --git a/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp index 690782d..321d1d0 100644 --- a/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_sym_key_generator.cpp @@ -90,7 +90,7 @@ static bool BuildContextForGenerateKey(napi_env env, napi_callback_info info, Sy return false; } context->asyncType = isCallback(env, argv[expectedArgc - 1], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiSymKeyGenerator *napiGenerator; + NapiSymKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap NapiSymKeyGenerator obj!"); @@ -129,7 +129,7 @@ static bool BuildContextForConvertKey(napi_env env, napi_callback_info info, Sym } context->asyncType = isCallback(env, argv[expectedArgc - 1], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE; - NapiSymKeyGenerator *napiGenerator; + NapiSymKeyGenerator *napiGenerator = nullptr; napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiGenerator)); if (status != napi_ok || napiGenerator == nullptr) { LOGE("failed to unwrap NapiSymKeyGenerator obj!"); diff --git a/frameworks/js/napi/crypto/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp index cb55d6c..be45baa 100644 --- a/frameworks/js/napi/crypto/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -245,9 +245,6 @@ static HcfBlob *GetAadFromParamsSpec(napi_env env, napi_value arg) LOGE("Failed to allocate newBlob memory!"); return nullptr; } - blob->data = nullptr; - blob->len = 0; - LOGD("Input GCM Aad is Null"); return blob; } blob = GetBlobFromNapiDataBlob(env, data); diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index e51a801..a9e6321 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -923,11 +923,16 @@ HcfResult BuildVerifyJsRecoverCtx(napi_env env, napi_callback_info info, VerifyR HcfResult ret = GetBlobFromNapiValue(env, argv[PARAM0], ctx->signatureData); if (ret != HCF_SUCCESS) { + HcfFree(ctx->signatureData); + ctx->signatureData = nullptr; return ret; } if (napi_create_reference(env, thisVar, 1, &ctx->verifyRef) != napi_ok) { LOGE("create verify ref failed when do verify recover!"); + HcfBlobDataFree(ctx->signatureData); + HcfFree(ctx->signatureData); + ctx->signatureData = nullptr; return HCF_ERR_NAPI; } @@ -1031,7 +1036,6 @@ static napi_value NapiWrapVerify(napi_env env, napi_value instance, NapiVerify * if (status != napi_ok) { LOGE("failed to wrap napiVerify obj!"); delete napiVerify; - napiVerify = nullptr; return nullptr; } return instance; @@ -1039,7 +1043,6 @@ static napi_value NapiWrapVerify(napi_env env, napi_value instance, NapiVerify * napi_value NapiVerify::CreateJsVerify(napi_env env, napi_callback_info info) { - LOGD("Enter CreateJsVerify..."); size_t expectedArgc = PARAMS_NUM_ONE; size_t argc = expectedArgc; napi_value argv[PARAMS_NUM_ONE] = { nullptr }; diff --git a/frameworks/native/src/crypto_common.c b/frameworks/native/src/crypto_common.c index b3d00a2..f9a17dd 100644 --- a/frameworks/native/src/crypto_common.c +++ b/frameworks/native/src/crypto_common.c @@ -22,5 +22,5 @@ void OH_Crypto_FreeDataBlob(Crypto_DataBlob *dataBlob) if (dataBlob == NULL) { return; } - return HcfBlobDataFree((HcfBlob *)dataBlob); + HcfBlobDataFree((HcfBlob *)dataBlob); } \ No newline at end of file diff --git a/frameworks/native/src/signature.c b/frameworks/native/src/signature.c index ebcd1b8..ec1a3d8 100644 --- a/frameworks/native/src/signature.c +++ b/frameworks/native/src/signature.c @@ -46,12 +46,12 @@ struct OH_CryptoVerify { HcfResult (*setVerifySpecUint8Array)(HcfVerify *self, SignSpecItem item, HcfBlob blob); }; -OH_Crypto_ErrCode OH_CryptoVerify_Create(const char *algoName, OH_CryptoVerify **ctx) +OH_Crypto_ErrCode OH_CryptoVerify_Create(const char *algoName, OH_CryptoVerify **verify) { - if (ctx == NULL) { + if (verify == NULL) { return CRYPTO_INVALID_PARAMS; } - HcfResult ret = HcfVerifyCreate(algoName, (HcfVerify **)ctx); + HcfResult ret = HcfVerifyCreate(algoName, (HcfVerify **)verify); return GetOhCryptoErrCode(ret); } @@ -114,7 +114,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_SetParam(OH_CryptoVerify *ctx, CryptoSignature switch (type) { case CRYPTO_PSS_SALT_LEN_INT: case CRYPTO_PSS_TRAILER_FIELD_INT: - if (value->len != sizeof(int32_t) || ctx->setVerifySpecInt = NULL) { + if ((value->data == NULL) || (value->len != sizeof(int32_t))) { ret = HCF_INVALID_PARAMS; break; } diff --git a/plugin/openssl_plugin/common/src/ecc_openssl_common.c b/plugin/openssl_plugin/common/src/ecc_openssl_common.c index a667155..4afd54a 100644 --- a/plugin/openssl_plugin/common/src/ecc_openssl_common.c +++ b/plugin/openssl_plugin/common/src/ecc_openssl_common.c @@ -218,10 +218,10 @@ static HcfResult InitEcKeyByPriKey(const HcfBigInteger *priKey, EC_KEY *ecKey) int32_t ret = (int32_t)OpensslEcKeySetPrivateKey(ecKey, sk); if (ret != HCF_OPENSSL_SUCCESS) { LOGD("[error] OpensslEcKeySetPrivateKey failed."); - OpensslBnFree(sk); + OpensslBnClearFree(sk); return HCF_ERR_CRYPTO_OPERATION; } - OpensslBnFree(sk); + OpensslBnClearFree(sk); return HCF_SUCCESS; } @@ -256,7 +256,7 @@ static HcfResult SetEcPubKeyFromPriKey(const HcfBigInteger *priKey, EC_KEY *ecKe } } while (0); OpensslEcPointFree(point); - OpensslBnFree(sk); + OpensslBnClearFree(sk); return ret; } diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c index 48a9fbc..f38dd44 100644 --- a/plugin/openssl_plugin/common/src/openssl_adapter.c +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -846,7 +846,7 @@ int OpensslBioWrite(BIO *b, const void *data, int dlen) void OpensslBioFreeAll(BIO *a) { - return BIO_free_all(a); + BIO_free_all(a); } int OpensslRandPrivBytes(unsigned char *buf, int num) @@ -1126,7 +1126,7 @@ EVP_CIPHER *OpensslEvpCipherFetch(OSSL_LIB_CTX *ctx, const char *algorithm, cons void OpensslEvpCipherFree(EVP_CIPHER *cipher) { - return EVP_CIPHER_free(cipher); + EVP_CIPHER_free(cipher); } EVP_CIPHER_CTX *OpensslEvpCipherCtxNew(void) @@ -1235,7 +1235,7 @@ int OpensslDhComputeKeyPadded(unsigned char *key, const BIGNUM *pubKey, DH *dh) void OpensslDhFree(DH *dh) { - return DH_free(dh); + DH_free(dh); } int OpensslDhGenerateKey(DH *dh) @@ -1323,9 +1323,9 @@ int OpensslDhSet0Key(DH *dh, BIGNUM *pubKey, BIGNUM *privKey) return DH_set0_key(dh, pubKey, privKey); } -struct Sm2CipherTextSt *OpensslD2iSm2CipherText(const uint8_t *ciphertext, size_t ciphertext_len) +struct Sm2CipherTextSt *OpensslD2iSm2CipherText(const uint8_t *ciphertext, size_t ciphertextLen) { - return d2i_Sm2CipherText(NULL, &ciphertext, ciphertext_len); + return d2i_Sm2CipherText(NULL, &ciphertext, ciphertextLen); } void OpensslSm2CipherTextFree(struct Sm2CipherTextSt *sm2Text) @@ -1448,12 +1448,12 @@ EVP_KDF_CTX *OpensslEvpKdfCtxNew(EVP_KDF *kdf) void OpensslEvpKdfFree(EVP_KDF *kdf) { - return EVP_KDF_free(kdf); + EVP_KDF_free(kdf); } void OpensslEvpKdfCtxFree(EVP_KDF_CTX *ctx) { - return EVP_KDF_CTX_free(ctx); + EVP_KDF_CTX_free(ctx); } int OpensslEvpKdfDerive(EVP_KDF_CTX *ctx, unsigned char *key, size_t keylen, diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index b054a34..2cf833a 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -448,7 +448,7 @@ bool IsBigEndian(void) HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest) { - if (src == NULL || dest == NULL) { + if (src == NULL || src->data == NULL || dest == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index 9013131..b6615da 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -576,7 +576,7 @@ static HcfResult AllocateCcmOutput(CipherData *data, HcfBlob *input, HcfBlob *ou outLen += input->len; *isUpdateInput = true; } - uint32_t authTagLen = data->enc == ENCRYPT_MODE ? CCM_TAG_SIZE : 0; + uint32_t authTagLen = (data->enc == ENCRYPT_MODE) ? CCM_TAG_SIZE : 0; outLen += authTagLen + AES_BLOCK_SIZE; if (outLen == 0) { LOGE("output size is invaild!"); @@ -689,7 +689,7 @@ static HcfResult AllocateGcmOutput(CipherData *data, HcfBlob *input, HcfBlob *ou outLen += input->len; *isUpdateInput = true; } - uint32_t authTagLen = data->enc == ENCRYPT_MODE ? GCM_TAG_SIZE : 0; + uint32_t authTagLen = (data->enc == ENCRYPT_MODE) ? GCM_TAG_SIZE : 0; outLen += data->updateLen + authTagLen + AES_BLOCK_SIZE; if (outLen == 0) { LOGE("output size is invaild!"); diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c index 1534c7e..d17899b 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c @@ -176,8 +176,8 @@ static HcfResult SetDetailParams(HcfCipherRsaGeneratorSpiImpl *impl) (void)GetOpensslDigestAlg(attr.md, &md); (void)GetOpensslDigestAlg(attr.mgf1md, &mgf1md); // set md and mgf1md - if (OpensslEvpPkeyCtxSetRsaOaepMd(impl->ctx, md) != HCF_OPENSSL_SUCCESS - || OpensslEvpPkeyCtxSetRsaMgf1Md(impl->ctx, mgf1md) != HCF_OPENSSL_SUCCESS) { + if (OpensslEvpPkeyCtxSetRsaOaepMd(impl->ctx, md) != HCF_OPENSSL_SUCCESS || + OpensslEvpPkeyCtxSetRsaMgf1Md(impl->ctx, mgf1md) != HCF_OPENSSL_SUCCESS) { LOGD("[error] Set md or mgf1md fail"); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c index 7f4114b..fc6adc4 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c @@ -303,8 +303,8 @@ static HcfResult CheckParam(HcfCipherGeneratorSpi* self, enum HcfCryptoMode opMo cipherImpl->attr.paddingMode = HCF_ALG_NOPADDING; LOGD("Default paddingMode is %u", HCF_ALG_NOPADDING); } - if (cipherImpl->attr.paddingMode != HCF_ALG_NOPADDING && cipherImpl->attr.paddingMode != HCF_ALG_PADDING_PKCS5 - && cipherImpl->attr.paddingMode != HCF_ALG_PADDING_PKCS7) { + if (cipherImpl->attr.paddingMode != HCF_ALG_NOPADDING && cipherImpl->attr.paddingMode != HCF_ALG_PADDING_PKCS5 && + cipherImpl->attr.paddingMode != HCF_ALG_PADDING_PKCS7) { LOGE("Invalid padding mode %u", cipherImpl->attr.paddingMode); return HCF_INVALID_PARAMS; } @@ -475,7 +475,7 @@ static HcfResult AllocateGcmOutput(CipherData *data, HcfBlob *input, HcfBlob *ou outLen += input->len; *isUpdateInput = true; } - uint32_t authTagLen = data->enc == ENCRYPT_MODE ? GCM_TAG_SIZE : 0; + uint32_t authTagLen = (data->enc == ENCRYPT_MODE) ? GCM_TAG_SIZE : 0; outLen += data->updateLen + authTagLen + SM4_BLOCK_SIZE; if (outLen == 0) { LOGE("output size is invaild!"); diff --git a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c index aa63579..323dbb9 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -67,6 +67,10 @@ static const EVP_MD *OpensslGetMdAlgoFromString(const char *mdName) static HcfResult OpensslEngineUpdateMd(HcfMdSpi *self, HcfBlob *input) { + if (input == NULL) { + LOGE("The input is NULL!"); + return HCF_INVALID_PARAMS; + } if (OpensslGetMdCtx(self) == NULL) { LOGD("[error] The CTX is NULL!"); return HCF_ERR_CRYPTO_OPERATION; @@ -81,6 +85,10 @@ static HcfResult OpensslEngineUpdateMd(HcfMdSpi *self, HcfBlob *input) static HcfResult OpensslEngineDoFinalMd(HcfMdSpi *self, HcfBlob *output) { + if (output == NULL) { + LOGE("The output is NULL!"); + return HCF_INVALID_PARAMS; + } EVP_MD_CTX *localCtx = OpensslGetMdCtx(self); if (localCtx == NULL) { LOGE("The CTX is NULL!"); diff --git a/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c b/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c index e68075a..78bb969 100644 --- a/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/rand/src/rand_openssl.c @@ -76,6 +76,10 @@ static const char *GetRandAlgoName(HcfRandSpi *self) static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { (void)self; + if (seed == NULL) { + LOGE("The seed is NULL!"); + return; + } OpensslRandSeed(seed->data, seed->len); } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c index fc19d25..4ac193d 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/signature_rsa_openssl.c @@ -104,8 +104,6 @@ static void DestroyRsaSign(HcfObjectBase *self) impl->ctx = NULL; } HcfFree(impl); - impl = NULL; - LOGD("DestroyRsaSign success."); } static void DestroyRsaVerify(HcfObjectBase *self) @@ -126,8 +124,6 @@ static void DestroyRsaVerify(HcfObjectBase *self) impl->ctx = NULL; } HcfFree(impl); - impl = NULL; - LOGD("DestroyRsaVerify success."); } static HcfResult CheckInitKeyType(HcfKey *key, bool signing) @@ -628,7 +624,7 @@ static HcfResult EngineRecover(HcfVerifySpi *self, HcfBlob *signatureData, HcfBl size_t bufLen = 0; if (OpensslEvpPkeyVerifyRecover(impl->ctx, NULL, &bufLen, signatureData->data, signatureData->len) - != HCF_OPENSSL_SUCCESS) { + != HCF_OPENSSL_SUCCESS) { LOGE("[error] OpensslEvpPkeyVerifyRecover get len fail."); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; @@ -641,7 +637,7 @@ static HcfResult EngineRecover(HcfVerifySpi *self, HcfBlob *signatureData, HcfBl } if (OpensslEvpPkeyVerifyRecover(impl->ctx, buf, &bufLen, signatureData->data, signatureData->len) - != HCF_OPENSSL_SUCCESS) { + != HCF_OPENSSL_SUCCESS) { LOGE("[error] OpensslEvpPkeyVerifyRecover fail."); HcfPrintOpensslError(); HcfFree(buf); @@ -978,7 +974,7 @@ HcfResult HcfSignSpiRsaCreate(HcfSignatureParams *params, HcfSignSpi **returnObj } returnImpl->initFlag = UNINITIALIZED; returnImpl->saltLen = PSS_SALTLEN_INVALID_INIT; - returnImpl->operation = params->operation == HCF_ALG_ONLY_SIGN ? HCF_OPERATIOPN_ONLY_SIGN : HCF_OPERATION_SIGN; + returnImpl->operation = (params->operation == HCF_ALG_ONLY_SIGN) ? HCF_OPERATIOPN_ONLY_SIGN : HCF_OPERATION_SIGN; *returnObj = (HcfSignSpi *)returnImpl; return HCF_SUCCESS; } 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 52d8a23..44a43a7 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 @@ -1063,7 +1063,7 @@ static HcfResult CreateAlg25519PriKeyByPriKeySpec(const HcfAlg25519PriKeyParamsS static HcfResult EngineGenerateAlg25519PubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPubKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPubKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1097,7 +1097,7 @@ static HcfResult EngineGenerateAlg25519PubKeyBySpec(const HcfAsyKeyGeneratorSpi static HcfResult EngineGenerateAlg25519PriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPriKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPriKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1131,7 +1131,7 @@ static HcfResult EngineGenerateAlg25519PriKeyBySpec(const HcfAsyKeyGeneratorSpi static HcfResult EngineGenerateAlg25519KeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (paramsSpec == NULL) || (returnKeyPair == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnKeyPair == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1163,10 +1163,10 @@ static HcfResult EngineGenerateAlg25519KeyPairBySpec(const HcfAsyKeyGeneratorSpi return ret; } -HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) +HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj) { (void)params; - if (params == NULL || returnSpi == NULL) { + if (params == NULL || returnObj == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1185,14 +1185,14 @@ HcfResult HcfAsyKeyGeneratorSpiEd25519Create(HcfAsyKeyGenParams *params, HcfAsyK impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; - *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + *returnObj = (HcfAsyKeyGeneratorSpi *)impl; return HCF_SUCCESS; } -HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) +HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj) { (void)params; - if (params == NULL || returnSpi == NULL) { + if (params == NULL || returnObj == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1211,7 +1211,7 @@ HcfResult HcfAsyKeyGeneratorSpiX25519Create(HcfAsyKeyGenParams *params, HcfAsyKe impl->base.engineGeneratePubKeyBySpec = EngineGenerateAlg25519PubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateAlg25519PriKeyBySpec; - *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + *returnObj = (HcfAsyKeyGeneratorSpi *)impl; 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 6e0083f..8be2648 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 @@ -346,8 +346,7 @@ static HcfResult GetBigIntegerSpecFromDhPriKey(const HcfPriKey *self, const AsyK LOGE("Invalid class of self."); return HCF_INVALID_PARAMS; } - HcfResult ret = HCF_SUCCESS; - ret = GetBigIntegerSpec(NULL, self, item, returnBigInteger); + HcfResult ret = GetBigIntegerSpec(NULL, self, item, returnBigInteger); if (ret != HCF_SUCCESS) { LOGE("Get big integer failed."); } @@ -1159,7 +1158,7 @@ static HcfResult EngineConvertDhPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpe static HcfResult EngineGenerateDhKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (paramsSpec == NULL) || (returnKeyPair == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnKeyPair == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1184,7 +1183,7 @@ static HcfResult EngineGenerateDhKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self static HcfResult EngineGenerateDhPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPubKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPubKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1210,7 +1209,7 @@ static HcfResult EngineGenerateDhPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGenerateDhPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPriKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPriKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1231,9 +1230,9 @@ static HcfResult EngineGenerateDhPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, return ret; } -HcfResult HcfAsyKeyGeneratorSpiDhCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) +HcfResult HcfAsyKeyGeneratorSpiDhCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **generator) { - if (params == NULL || returnSpi == NULL) { + if (params == NULL || generator == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1253,6 +1252,6 @@ HcfResult HcfAsyKeyGeneratorSpiDhCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGen impl->base.engineGeneratePubKeyBySpec = EngineGenerateDhPubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateDhPriKeyBySpec; - *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + *generator = (HcfAsyKeyGeneratorSpi *)impl; return HCF_SUCCESS; } \ No newline at end of file diff --git a/plugin/openssl_plugin/key/asy_key_generator/src/dh_common_param_spec_generator_openssl.c b/plugin/openssl_plugin/key/asy_key_generator/src/dh_common_param_spec_generator_openssl.c index b02c648..928dab7 100644 --- a/plugin/openssl_plugin/key/asy_key_generator/src/dh_common_param_spec_generator_openssl.c +++ b/plugin/openssl_plugin/key/asy_key_generator/src/dh_common_param_spec_generator_openssl.c @@ -131,7 +131,7 @@ static HcfResult BuildCommonParam(EVP_PKEY *dhKey, HcfDhCommParamsSpecSpi *retur static HcfResult SetAlgName(const char *algName, char **returnAlgName) { size_t srcAlgNameLen = HcfStrlen(algName); - if (!srcAlgNameLen) { + if (srcAlgNameLen == 0) { LOGE("AlgName is empty!"); return HCF_INVALID_PARAMS; } @@ -140,11 +140,7 @@ static HcfResult SetAlgName(const char *algName, char **returnAlgName) LOGE("Failed to malloc algName memory."); return HCF_ERR_MALLOC; } - if (memcpy_s(*returnAlgName, srcAlgNameLen, algName, srcAlgNameLen) != EOK) { - LOGD("[error] Failed to memcpy algName."); - HcfFree(*returnAlgName); - return HCF_ERR_CRYPTO_OPERATION; - } + (void)memcpy_s(*returnAlgName, srcAlgNameLen + 1, algName, srcAlgNameLen); return HCF_SUCCESS; } 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 8d7e8a2..2dff817 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 @@ -1009,7 +1009,7 @@ static HcfResult EngineConvertDsaPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSp static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (paramsSpec == NULL) || (returnKeyPair == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnKeyPair == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1033,7 +1033,7 @@ static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *sel static HcfResult EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPubKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPubKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1058,7 +1058,7 @@ static HcfResult EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self static HcfResult EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey) { - if ((self == NULL) || (paramsSpec == NULL) || (returnPriKey == NULL)) { + if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPriKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1080,9 +1080,9 @@ static HcfResult EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self return ret; } -HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnSpi) +HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj) { - if (params == NULL || returnSpi == NULL) { + if (params == NULL || returnObj == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1102,6 +1102,6 @@ HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGe impl->base.engineGeneratePubKeyBySpec = EngineGenerateDsaPubKeyBySpec; impl->base.engineGeneratePriKeyBySpec = EngineGenerateDsaPriKeyBySpec; - *returnSpi = (HcfAsyKeyGeneratorSpi *)impl; + *returnObj = (HcfAsyKeyGeneratorSpi *)impl; return HCF_SUCCESS; } 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 e2c8c8d..3289032 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 @@ -1066,8 +1066,7 @@ static OSSL_PARAM *ConvertHcfBlobToOsslParams(const char *groupName, HcfBlob *po OpensslOsslParamBldFree(paramBld); return NULL; } - if (OpensslOsslParamBldPushOctetString(paramBld, "pub", pointBlob->data, pointBlob->len) - != HCF_OPENSSL_SUCCESS) { + if (OpensslOsslParamBldPushOctetString(paramBld, "pub", pointBlob->data, pointBlob->len) != HCF_OPENSSL_SUCCESS) { LOGE("Invalid pointBlob parameter."); OpensslOsslParamBldFree(paramBld); return NULL; @@ -1133,6 +1132,10 @@ static EC_KEY *ConvertOsslParamsToEccPubKey(const char *groupName, int32_t curve static HcfResult GetCompressedEccPointEncoded(HcfOpensslEccPubKey *impl, HcfBlob *returnBlob) { EC_KEY *ecKey = impl->ecKey; + if (ecKey == NULL) { + LOGE("EcKey is NULL."); + return HCF_INVALID_PARAMS; + } const EC_GROUP *group = OpensslEcKeyGet0Group(ecKey); if (group == NULL) { LOGE("Failed to get group."); @@ -1473,7 +1476,7 @@ static HcfResult GetEcKeySpecBigInteger(const HcfKey *self, const AsyKeySpecItem LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult res = CheckEcKeySelf(self, &isPrivate); if (res != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -1517,7 +1520,7 @@ static HcfResult GetEcKeySpecString(const HcfKey *self, const AsyKeySpecItem ite LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult res = CheckEcKeySelf(self, &isPrivate); if (res != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -1545,7 +1548,7 @@ static HcfResult GetEcKeySpecInt(const HcfKey *self, const AsyKeySpecItem item, LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult res = CheckEcKeySelf(self, &isPrivate); if (res != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -1723,7 +1726,7 @@ static HcfResult ConvertEcPubKey(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpenss OpensslEcKeyFree(ecKey); return res; } - return HCF_SUCCESS; + return HCF_SUCCESS; } static HcfResult ConvertPriFromEncoded(EC_KEY **eckey, HcfBlob *priKeyBlob) @@ -2012,7 +2015,8 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (returnKeyPair == NULL)) { + if ((self == NULL) || (returnKeyPair == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -2047,7 +2051,8 @@ static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfPubKey **returnPubKey) { - if ((self == NULL) || (returnPubKey == NULL)) { + if ((self == NULL) || (returnPubKey == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -2079,7 +2084,8 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfPriKey **returnPriKey) { - if ((self == NULL) || (returnPriKey == NULL)) { + if ((self == NULL) || (returnPriKey == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } 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 4ad98a2..4532190 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 @@ -353,6 +353,7 @@ static HcfResult CopyStrFromBIO(BIO *bio, char **returnString) LOGE("Bio read fail"); HcfPrintOpensslError(); HcfFree(*returnString); + *returnString = NULL; return HCF_ERR_CRYPTO_OPERATION; } return HCF_SUCCESS; @@ -1151,6 +1152,11 @@ static HcfResult EngineConvertPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec } } + if (pubKey == NULL && priKey == NULL) { + LOGE("Convert key failed with invalid blob"); + return HCF_INVALID_PARAMS; + } + HcfOpensslRsaKeyPair *keyPair = (HcfOpensslRsaKeyPair *)HcfMalloc(sizeof(HcfOpensslRsaKeyPair), 0); if (keyPair == NULL) { LOGE("Malloc keyPair fail."); @@ -1337,7 +1343,7 @@ static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyParamsSpec *paramsSpec, Hcf static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (returnKeyPair == NULL) || (paramsSpec == NULL)) { + if ((self == NULL) || (returnKeyPair == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL)) { LOGE("GenerateKeyPairBySpec Params is invalid."); return HCF_INVALID_PARAMS; } @@ -1359,7 +1365,7 @@ static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey) { - if ((self == NULL) || (returnPubKey == NULL) || (paramsSpec == NULL)) { + if ((self == NULL) || (returnPubKey == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL)) { LOGE("GeneratePubKeyBySpec Params is invalid."); return HCF_INVALID_PARAMS; } @@ -1381,7 +1387,7 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey) { - if ((self == NULL) || (returnPriKey == NULL) || (paramsSpec == NULL)) { + if ((self == NULL) || (returnPriKey == NULL) || (paramsSpec == NULL) || || (paramsSpec->algName == NULL)) { LOGE("GeneratePriKeyBySpec Params is invalid."); return HCF_INVALID_PARAMS; } @@ -1444,6 +1450,7 @@ static HcfResult DecodeParams(HcfAsyKeyGenParams *from, HcfAsyKeyGenSpiRsaParams } if (CheckRsaKeyGenParams(*to) != HCF_SUCCESS) { LOGE("Invalid keyGen params"); + OpensslBnFree((*to)->pubExp); HcfFree(*to); *to = NULL; return HCF_INVALID_PARAMS; 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 35d5191..e96af97 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 @@ -568,11 +568,7 @@ static HcfResult GetCurveName(const HcfKey *self, bool isPriavte, char **returnS LOGE("Allocate returnString memory failed."); return HCF_ERR_MALLOC; } - if (memcpy_s(*returnString, len, curveIdStr, len) != EOK) { - LOGE("Memcpy returnString failed."); - HcfFree(*returnString); - return HCF_ERR_MALLOC; - } + (void)memcpy_s(*returnString, len, curveIdStr, len); return HCF_SUCCESS; } @@ -600,7 +596,7 @@ static HcfResult GetSm2KeySpecBigInteger(const HcfKey *self, const AsyKeySpecIte LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult ret = CheckSm2KeySelf(self, &isPrivate); if (ret != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -648,7 +644,7 @@ static HcfResult GetSm2KeySpecString(const HcfKey *self, const AsyKeySpecItem it LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult ret = CheckSm2KeySelf(self, &isPrivate); if (ret != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -676,7 +672,7 @@ static HcfResult GetSm2KeySpecInt(const HcfKey *self, const AsyKeySpecItem item, LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } - bool isPrivate; + bool isPrivate = false; HcfResult ret = CheckSm2KeySelf(self, &isPrivate); if (ret != HCF_SUCCESS) { LOGE("Invalid input key"); @@ -1226,7 +1222,8 @@ static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair * static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfKeyPair **returnKeyPair) { - if ((self == NULL) || (returnKeyPair == NULL)) { + if ((self == NULL) || (returnKeyPair == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field != NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1261,7 +1258,8 @@ static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfPubKey **returnPubKey) { - if ((self == NULL) || (returnPubKey == NULL)) { + if ((self == NULL) || (returnPubKey == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field != NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1293,7 +1291,8 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params, HcfPriKey **returnPriKey) { - if ((self == NULL) || (returnPriKey == NULL)) { + if ((self == NULL) || (returnPriKey == NULL) || (params == NULL) || + (((HcfEccCommParamsSpec *)params)->field != NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } -- Gitee From 4c3537294844d652d785f2f8de44163dbcadafed Mon Sep 17 00:00:00 2001 From: zxz*3 Date: Sun, 25 Aug 2024 00:03:15 +0800 Subject: [PATCH 19/32] fix issue Signed-off-by: zxz*3 --- common/src/asy_key_params.c | 2 +- common/src/object_base.c | 2 +- frameworks/js/napi/crypto/src/napi_cipher.cpp | 2 +- frameworks/key/ecc_key_util.c | 2 +- frameworks/key/sym_key_generator.c | 14 +++++--- frameworks/native/src/asym_key.c | 36 ++++++++----------- frameworks/native/src/signature.c | 2 +- frameworks/native/src/sym_key.c | 2 +- .../src/rsa_asy_key_generator_openssl.c | 2 +- 9 files changed, 32 insertions(+), 32 deletions(-) diff --git a/common/src/asy_key_params.c b/common/src/asy_key_params.c index a929b03..415ab5a 100644 --- a/common/src/asy_key_params.c +++ b/common/src/asy_key_params.c @@ -461,7 +461,7 @@ void FreeAsyKeySpec(HcfAsyKeyParamsSpec *spec) return; } HcfFreeParamsAsyKeySpec createFreeFunc = FindAsyKeySpecFreeAbility(spec); - if (createFreeFunc != NULL) { + if (createFreeFunc != NULL) { createFreeFunc(spec); } else { LOGE("create freeFunc failed."); diff --git a/common/src/object_base.c b/common/src/object_base.c index 3df1ee6..15d1090 100644 --- a/common/src/object_base.c +++ b/common/src/object_base.c @@ -20,7 +20,7 @@ void HcfObjDestroy(void *obj) { HcfObjectBase *tmp = (HcfObjectBase *)obj; - if (tmp != NULL && tmp->destory != NULL) { + if (tmp != NULL && tmp->destroy != NULL) { tmp->destroy(tmp); } } diff --git a/frameworks/js/napi/crypto/src/napi_cipher.cpp b/frameworks/js/napi/crypto/src/napi_cipher.cpp index da2fdc3..ac947b7 100644 --- a/frameworks/js/napi/crypto/src/napi_cipher.cpp +++ b/frameworks/js/napi/crypto/src/napi_cipher.cpp @@ -730,7 +730,7 @@ napi_value NapiCipher::JsCipherDoFinalSync(napi_env env, napi_callback_info info napi_value instance = nullptr; res = ConvertDataBlobToNapiValue(env, &output, &instance); - HcfBlobDataClearAndFree(&output) + HcfBlobDataClearAndFree(&output); if (res != HCF_SUCCESS) { LOGE("cipher convert dataBlob to napi_value failed!"); napi_throw(env, GenerateBusinessError(env, res, "cipher convert dataBlob to napi_value failed!")); diff --git a/frameworks/key/ecc_key_util.c b/frameworks/key/ecc_key_util.c index a57abb4..3156568 100644 --- a/frameworks/key/ecc_key_util.c +++ b/frameworks/key/ecc_key_util.c @@ -185,7 +185,7 @@ HcfResult HcfEccKeyUtilCreate(const char *algName, HcfEccCommParamsSpec **return LOGE("Failed to create spi object!"); return ret; } - ret = CreateEccCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec) + ret = CreateEccCommonSpecImpl(&(spiInstance->paramsSpec), returnCommonParamSpec); if (ret != HCF_SUCCESS) { LOGE("Failed to create spi object!"); } diff --git a/frameworks/key/sym_key_generator.c b/frameworks/key/sym_key_generator.c index fa276c1..0b9f646 100644 --- a/frameworks/key/sym_key_generator.c +++ b/frameworks/key/sym_key_generator.c @@ -206,7 +206,7 @@ static void DestroySymmKeyGenerator(HcfObjectBase *base) static HcfResult GenerateSymmKey(HcfSymKeyGenerator *self, HcfSymKey **symmKey) { - if ((self == NULL) || (symmKey == NULL) || impl->spiObj == NULL || impl->spiObj->engineGenerateSymmKey == NULL) { + if ((self == NULL) || (symmKey == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -216,14 +216,17 @@ static HcfResult GenerateSymmKey(HcfSymKeyGenerator *self, HcfSymKey **symmKey) return HCF_INVALID_PARAMS; } HcfSymmKeyGeneratorImpl *impl = (HcfSymmKeyGeneratorImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineGenerateSymmKey == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineGenerateSymmKey(impl->spiObj, symmKey); } static HcfResult ConvertSymmKey(HcfSymKeyGenerator *self, const HcfBlob *key, HcfSymKey **symmKey) { - if ((self == NULL) || (symmKey == NULL) || !HcfIsBlobValid(key) || impl->spiObj == NULL || - impl->spiObj->engineConvertSymmKey == NULL) { + if ((self == NULL) || (symmKey == NULL) || !HcfIsBlobValid(key)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -232,7 +235,10 @@ static HcfResult ConvertSymmKey(HcfSymKeyGenerator *self, const HcfBlob *key, Hc return HCF_INVALID_PARAMS; } HcfSymmKeyGeneratorImpl *impl = (HcfSymmKeyGeneratorImpl *)self; - + if (impl->spiObj == NULL || impl->spiObj->engineConvertSymmKey == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineConvertSymmKey(impl->spiObj, key, symmKey); } diff --git a/frameworks/native/src/asym_key.c b/frameworks/native/src/asym_key.c index 8959d00..5007aa7 100644 --- a/frameworks/native/src/asym_key.c +++ b/frameworks/native/src/asym_key.c @@ -92,14 +92,13 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c const char *pubKeyStr = (pubKeyData == NULL)? NULL : (const char *)pubKeyData->data; switch (type) { case CRYPTO_PEM: - ret = ctx->convertPemKey == NULL - ? CRYPTO_INVALID_PARAMS - : ctx->convertPemKey((HcfAsyKeyGenerator *)ctx, NULL, pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx); + ret = ctx->convertPemKey == NULL ? HCF_INVALID_PARAMS : + ctx->convertPemKey((HcfAsyKeyGenerator *)ctx, NULL, pubKeyStr, priKeyStr, (HcfKeyPair **)keyCtx); break; case CRYPTO_DER: - ret = ctx->convertKey == NULL ? CRYPTO_INVALID_PARAMS - : ctx->convertKey((HcfAsyKeyGenerator *)ctx, NULL, (HcfBlob *)pubKeyData, - (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); + ret = ctx->convertKey == NULL ? HCF_INVALID_PARAMS : + ctx->convertKey((HcfAsyKeyGenerator *)ctx, NULL, (HcfBlob *)pubKeyData, + (HcfBlob *)priKeyData, (HcfKeyPair **)keyCtx); break; default: return CRYPTO_INVALID_PARAMS; @@ -109,7 +108,7 @@ OH_Crypto_ErrCode OH_CryptoAsymKeyGenerator_Convert(OH_CryptoAsymKeyGenerator *c const char *OH_CryptoAsymKeyGenerator_GetAlgoName(OH_CryptoAsymKeyGenerator *ctx) { - if ((ctx == NULL) || c(tx->getAlgoName == NULL)) { + if ((ctx == NULL) || (ctx->getAlgoName == NULL)) { return NULL; } return ctx->getAlgoName((HcfAsyKeyGenerator *)ctx); @@ -161,12 +160,11 @@ OH_Crypto_ErrCode OH_CryptoPubKey_Encode(OH_CryptoPubKey *key, Crypto_EncodingTy break; case CRYPTO_DER: if (encodingStandard != NULL) { - ret = key->getEncodedDer == NULL - ? CRYPTO_INVALID_PARAMS - : key->getEncodedDer((HcfPubKey *)key, encodingStandard, (HcfBlob *)out); + ret = key->getEncodedDer == NULL ? HCF_INVALID_PARAMS : + key->getEncodedDer((HcfPubKey *)key, encodingStandard, (HcfBlob *)out); break; } else { - ret = key->base.getEncoded == NULL ? CRYPTO_INVALID_PARAMS + ret = key->base.getEncoded == NULL ? HCF_INVALID_PARAMS : key->base.getEncoded((HcfKey *)key, (HcfBlob *)out); break; } @@ -195,9 +193,8 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P ret = HCF_ERR_MALLOC; break; } - ret = key->getAsyKeySpecInt == NULL - ? CRYPTO_INVALID_PARAMS - : key->getAsyKeySpecInt((HcfPubKey *)key, (AsyKeySpecItem)item, returnInt); + ret = key->getAsyKeySpecInt == NULL ? HCF_INVALID_PARAMS : + key->getAsyKeySpecInt((HcfPubKey *)key, (AsyKeySpecItem)item, returnInt); if (ret != HCF_SUCCESS) { HcfFree(returnInt); break; @@ -207,9 +204,8 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P break; case CRYPTO_ECC_FIELD_TYPE_STR: case CRYPTO_ECC_CURVE_NAME_STR: - ret = key->getAsyKeySpecString == NULL - ? CRYPTO_INVALID_PARAMS - : key->getAsyKeySpecString((HcfPubKey *)key, (AsyKeySpecItem)item, &returnStr); + ret = key->getAsyKeySpecString == NULL ? HCF_INVALID_PARAMS : + key->getAsyKeySpecString((HcfPubKey *)key, (AsyKeySpecItem)item, &returnStr); if (ret != HCF_SUCCESS) { break; } @@ -217,10 +213,8 @@ OH_Crypto_ErrCode OH_CryptoPubKey_GetParam(OH_CryptoPubKey *key, CryptoAsymKey_P value->len = strlen(returnStr); break; default: - ret = key->getAsyKeySpecBigInteger == NULL - ? CRYPTO_INVALID_PARAMS - : key->getAsyKeySpecBigInteger((HcfPubKey *)key, - (AsyKeySpecItem)item, &bigIntValue); + ret = key->getAsyKeySpecBigInteger == NULL ? HCF_INVALID_PARAMS : + key->getAsyKeySpecBigInteger((HcfPubKey *)key, (AsyKeySpecItem)item, &bigIntValue); if (ret != HCF_SUCCESS) { break; } diff --git a/frameworks/native/src/signature.c b/frameworks/native/src/signature.c index ec1a3d8..c619321 100644 --- a/frameworks/native/src/signature.c +++ b/frameworks/native/src/signature.c @@ -114,7 +114,7 @@ OH_Crypto_ErrCode OH_CryptoVerify_SetParam(OH_CryptoVerify *ctx, CryptoSignature switch (type) { case CRYPTO_PSS_SALT_LEN_INT: case CRYPTO_PSS_TRAILER_FIELD_INT: - if ((value->data == NULL) || (value->len != sizeof(int32_t))) { + if ((value->data == NULL) || (value->len != sizeof(int32_t)) || (ctx->setVerifySpecInt == NULL)) { ret = HCF_INVALID_PARAMS; break; } diff --git a/frameworks/native/src/sym_key.c b/frameworks/native/src/sym_key.c index d5d44c9..4d96267 100644 --- a/frameworks/native/src/sym_key.c +++ b/frameworks/native/src/sym_key.c @@ -88,7 +88,7 @@ void OH_CryptoSymKeyGenerator_Destroy(OH_CryptoSymKeyGenerator *ctx) const char *OH_CryptoSymKey_GetAlgoName(OH_CryptoSymKey *keyCtx) { - if (keyCtx == NUL || (keyCtx->key.getAlgorithm == NULL)L) { + if (keyCtx == NULL || (keyCtx->key.getAlgorithm == NULL)) { return NULL; } return keyCtx->key.getAlgorithm((HcfKey *)keyCtx); 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 4532190..286fb3a 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 @@ -1387,7 +1387,7 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey) { - if ((self == NULL) || (returnPriKey == NULL) || (paramsSpec == NULL) || || (paramsSpec->algName == NULL)) { + if ((self == NULL) || (returnPriKey == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL)) { LOGE("GeneratePriKeyBySpec Params is invalid."); return HCF_INVALID_PARAMS; } -- Gitee From 9f7ae4866da1e1000beb83102be724d809c12cc5 Mon Sep 17 00:00:00 2001 From: zxz*3 Date: Sun, 25 Aug 2024 11:01:35 +0800 Subject: [PATCH 20/32] fix issue Signed-off-by: zxz*3 --- common/src/hcf_parcel.c | 2 +- frameworks/key/asy_key_generator.c | 48 ++++++++++++++----- .../common/src/openssl_common.c | 2 +- .../src/sm2_asy_key_generator_openssl.c | 6 +-- 4 files changed, 41 insertions(+), 17 deletions(-) diff --git a/common/src/hcf_parcel.c b/common/src/hcf_parcel.c index 4f05927..9573128 100644 --- a/common/src/hcf_parcel.c +++ b/common/src/hcf_parcel.c @@ -144,7 +144,7 @@ static uint32_t GetParcelIncreaseSize(HcParcel *parcel, uint32_t newSize) bool ParcelWrite(HcParcel *parcel, const void *src, uint32_t dataSize) { errno_t rc; - if (parcel == NULL || parcel->data == NULL || src == NULL || dataSize == 0) { + if (parcel == NULL || src == NULL || dataSize == 0) { return false; } if (parcel->endPos > PARCEL_UINT_MAX - dataSize) { diff --git a/frameworks/key/asy_key_generator.c b/frameworks/key/asy_key_generator.c index 4317eeb..479af45 100644 --- a/frameworks/key/asy_key_generator.c +++ b/frameworks/key/asy_key_generator.c @@ -1225,28 +1225,36 @@ static const char *GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec *self) static HcfResult ConvertKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob, HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair) { - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineConvertKey == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineConvertKey == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineConvertKey(impl->spiObj, params, pubKeyBlob, priKeyBlob, returnKeyPair); } static HcfResult ConvertPemKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, const char *pubKeyStr, const char *priKeyStr, HcfKeyPair **returnKeyPair) { - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineConvertPemKey == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineConvertPemKey == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineConvertPemKey(impl->spiObj, params, pubKeyStr, priKeyStr, returnKeyPair); } @@ -1254,53 +1262,69 @@ static HcfResult GenerateKeyPair(HcfAsyKeyGenerator *self, HcfParamsSpec *params HcfKeyPair **returnKeyPair) { (void)params; - HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPair == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPair == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineGenerateKeyPair(impl->spiObj, returnKeyPair); } static HcfResult GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfKeyPair **returnKeyPair) { - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPairBySpec == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPairBySpec == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineGenerateKeyPairBySpec(impl->spiObj, impl->paramsSpec, returnKeyPair); } static HcfResult GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPubKey **returnPubKey) { - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGeneratePubKeyBySpec == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineGeneratePubKeyBySpec == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineGeneratePubKeyBySpec(impl->spiObj, impl->paramsSpec, returnPubKey); } static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPriKey **returnPriKey) { - HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; - if (self == NULL || impl->spiObj == NULL || impl->spiObj->engineGeneratePriKeyBySpec == NULL) { + if (self == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) { return HCF_INVALID_PARAMS; } + HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self; + if (impl->spiObj == NULL || impl->spiObj->engineGeneratePriKeyBySpec == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } return impl->spiObj->engineGeneratePriKeyBySpec(impl->spiObj, impl->paramsSpec, returnPriKey); } diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 2cf833a..b054a34 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -448,7 +448,7 @@ bool IsBigEndian(void) HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest) { - if (src == NULL || src->data == NULL || dest == NULL) { + if (src == NULL || dest == NULL) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } 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 e96af97..0129be4 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 @@ -1223,7 +1223,7 @@ static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnKeyPair) { if ((self == NULL) || (returnKeyPair == NULL) || (params == NULL) || - (((HcfEccCommParamsSpec *)params)->field != NULL)) { + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1259,7 +1259,7 @@ static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c HcfPubKey **returnPubKey) { if ((self == NULL) || (returnPubKey == NULL) || (params == NULL) || - (((HcfEccCommParamsSpec *)params)->field != NULL)) { + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } @@ -1292,7 +1292,7 @@ static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, c HcfPriKey **returnPriKey) { if ((self == NULL) || (returnPriKey == NULL) || (params == NULL) || - (((HcfEccCommParamsSpec *)params)->field != NULL)) { + (((HcfEccCommParamsSpec *)params)->field == NULL)) { LOGE("Invalid input parameter."); return HCF_INVALID_PARAMS; } -- Gitee From ea4c16afd26b7e8af61d2e2455fe35eace8a3bdc Mon Sep 17 00:00:00 2001 From: lanming Date: Sun, 25 Aug 2024 16:39:48 +0800 Subject: [PATCH 21/32] fix issue Signed-off-by: lanming --- .../js/napi/crypto/src/napi_asy_key_generator.cpp | 5 ----- frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp | 1 + frameworks/js/napi/crypto/src/napi_pri_key.cpp | 10 ++-------- frameworks/js/napi/crypto/src/napi_utils.cpp | 3 +++ frameworks/js/napi/crypto/src/napi_verify.cpp | 5 ----- .../crypto_operation/cipher/src/cipher_aes_openssl.c | 1 - .../crypto_operation/cipher/src/cipher_sm4_openssl.c | 1 - .../src/alg_25519_asy_key_generator_openssl.c | 1 - .../src/ecc_common_param_spec_generator_openssl.c | 3 +++ .../src/rsa_asy_key_generator_openssl.c | 5 ----- 10 files changed, 9 insertions(+), 26 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 5426604..8694588 100644 --- a/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp +++ b/frameworks/js/napi/crypto/src/napi_asy_key_generator.cpp @@ -903,11 +903,6 @@ napi_value NapiAsyKeyGenerator::JsConvertPemKeySync(napi_env env, napi_callback_ } napi_value instance = napiKeyPair->ConvertToJsKeyPair(env); - if (instance == nullptr) { - LOGE("covert to jsKeyPair failed!"); - instance = NapiGetNull(env); - } - return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp b/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp index 00edecb..0cd9cee 100644 --- a/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp +++ b/frameworks/js/napi/crypto/src/napi_ecc_key_util.cpp @@ -59,6 +59,7 @@ napi_value NapiECCKeyUtil::JsGenECCCommonParamsSpec(napi_env env, napi_callback_ } napi_value instance = ConvertEccCommParamsSpecToNapiValue(env, eccCommParamsSpec); FreeEccCommParamsSpec(eccCommParamsSpec); + HcfFree(eccCommParamsSpec); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_pri_key.cpp b/frameworks/js/napi/crypto/src/napi_pri_key.cpp index 2593292..25ae8f2 100644 --- a/frameworks/js/napi/crypto/src/napi_pri_key.cpp +++ b/frameworks/js/napi/crypto/src/napi_pri_key.cpp @@ -182,13 +182,13 @@ static napi_value GetAsyKeySpecBigInt(napi_env env, AsyKeySpecItem item, HcfPriK } napi_value instance = ConvertBigIntToNapiValue(env, &returnBigInteger); + (void)memset_s(returnBigInteger.data, returnBigInteger.len, 0, returnBigInteger.len); + HcfFree(returnBigInteger.data); if (instance == nullptr) { - HcfFree(returnBigInteger.data); napi_throw(env, GenerateBusinessError(env, res, "covert bigInt to napi value failed.")); LOGE("covert bigInt to napi value failed."); return nullptr; } - HcfFree(returnBigInteger.data); return instance; } @@ -310,12 +310,6 @@ napi_value NapiPriKey::JsGetEncodedDer(napi_env env, napi_callback_info info) } napi_value instance = ConvertBlobToNapiValue(env, &returnBlob); - if (instance == nullptr) { - HcfBlobDataFree(&returnBlob); - napi_throw(env, GenerateBusinessError(env, res, "covert blob to napi value failed.")); - LOGE("covert blob to napi value failed."); - return nullptr; - } HcfBlobDataClearAndFree(&returnBlob); return instance; } diff --git a/frameworks/js/napi/crypto/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp index be45baa..b95168b 100644 --- a/frameworks/js/napi/crypto/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -1526,6 +1526,7 @@ napi_value ConvertBlobToNapiValue(napi_env env, HcfBlob *blob) env, buffer, blob->len, [](napi_env env, void *data, void *hint) { HcfFree(data); }, nullptr, &outBuffer); if (status != napi_ok) { LOGE("create uint8 array buffer failed!"); + (void)memset_s(buffer, blob->len, 0, blob->len); HcfFree(buffer); return NapiGetNull(env); } @@ -1639,6 +1640,7 @@ napi_value ConvertBigIntToNapiValue(napi_env env, HcfBigInteger *blob) if (status != napi_ok) { napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "create bigint failed!")); LOGE("create bigint failed!"); + (void)memset_s(words, wordsCount * sizeof(uint64_t), 0, wordsCount * sizeof(uint64_t)); HcfFree(words); return NapiGetNull(env); } @@ -1646,6 +1648,7 @@ napi_value ConvertBigIntToNapiValue(napi_env env, HcfBigInteger *blob) napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "bigInt is null!")); LOGE("bigInt is null!"); } + (void)memset_s(words, wordsCount * sizeof(uint64_t), 0, wordsCount * sizeof(uint64_t)); HcfFree(words); words = nullptr; return bigInt; diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index a9e6321..a03a02c 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -923,16 +923,11 @@ HcfResult BuildVerifyJsRecoverCtx(napi_env env, napi_callback_info info, VerifyR HcfResult ret = GetBlobFromNapiValue(env, argv[PARAM0], ctx->signatureData); if (ret != HCF_SUCCESS) { - HcfFree(ctx->signatureData); - ctx->signatureData = nullptr; return ret; } if (napi_create_reference(env, thisVar, 1, &ctx->verifyRef) != napi_ok) { LOGE("create verify ref failed when do verify recover!"); - HcfBlobDataFree(ctx->signatureData); - HcfFree(ctx->signatureData); - ctx->signatureData = nullptr; return HCF_ERR_NAPI; } diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index b6615da..d3df53b 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -350,7 +350,6 @@ static HcfResult InitCipherData(HcfCipherGeneratorSpi *self, enum HcfCryptoMode ret = InitAadAndTagFromGcmParams(opMode, (HcfGcmParamsSpec *)params, *cipherData); break; default: - ret = HCF_NOT_SUPPORT; break; } if (ret != HCF_SUCCESS) { diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c index fc6adc4..0d3fafd 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm4_openssl.c @@ -246,7 +246,6 @@ static HcfResult InitCipherData(HcfCipherGeneratorSpi* self, enum HcfCryptoMode ret = HCF_NOT_SUPPORT; break; default: - ret = HCF_NOT_SUPPORT; break; } if (ret != HCF_SUCCESS) { 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 44a43a7..d29922b 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 @@ -82,7 +82,6 @@ static void DestroyAlg25519KeyGeneratorSpiImpl(HcfObjectBase *self) return; } LOGE("Invalid input parameter."); - return; } static void DestroyAlg25519PubKey(HcfObjectBase *self) 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 8630d23..aa460d8 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 @@ -216,6 +216,9 @@ static void FreeEccCommParamObject(HcfEccCommParamsSpecSpi *spec) HcfFree(spec->paramsSpec.base.algName); spec->paramsSpec.base.algName = NULL; if (spec->paramsSpec.field != NULL) { + HcfECFieldFp *tmp = (HcfECFieldFp *)spec->paramsSpec.field; + HcfFree(tmp->p.data); + tmp->p.data = NULL; HcfFree(spec->paramsSpec.field->fieldType); spec->paramsSpec.field->fieldType = NULL; HcfFree(spec->paramsSpec.field); 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 286fb3a..ed43ee8 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 @@ -1152,11 +1152,6 @@ static HcfResult EngineConvertPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec } } - if (pubKey == NULL && priKey == NULL) { - LOGE("Convert key failed with invalid blob"); - return HCF_INVALID_PARAMS; - } - HcfOpensslRsaKeyPair *keyPair = (HcfOpensslRsaKeyPair *)HcfMalloc(sizeof(HcfOpensslRsaKeyPair), 0); if (keyPair == NULL) { LOGE("Malloc keyPair fail."); -- Gitee From 442161305b68ddcad22da86d492f13d06b8141bd Mon Sep 17 00:00:00 2001 From: lcc Date: Sat, 31 Aug 2024 16:38:40 +0800 Subject: [PATCH 22/32] =?UTF-8?q?=E7=AE=97=E6=B3=95=E5=BA=93=E5=A2=9E?= =?UTF-8?q?=E5=8A=A0CFI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- common/BUILD.gn | 1 + frameworks/BUILD.gn | 1 + frameworks/cj/BUILD.gn | 1 + frameworks/js/napi/crypto/BUILD.gn | 1 + frameworks/native/BUILD.gn | 1 + plugin/BUILD.gn | 1 + 6 files changed, 6 insertions(+) diff --git a/common/BUILD.gn b/common/BUILD.gn index f216116..965bd6c 100644 --- a/common/BUILD.gn +++ b/common/BUILD.gn @@ -15,6 +15,7 @@ import("//base/security/crypto_framework/common/common.gni") import("//build/ohos.gni") ohos_static_library("crypto_plugin_common") { + branch_protector_ret = "pac_ret" subsystem_name = "security" part_name = "crypto_framework" include_dirs = crypto_framwork_common_inc_path diff --git a/frameworks/BUILD.gn b/frameworks/BUILD.gn index 11b713a..c861451 100644 --- a/frameworks/BUILD.gn +++ b/frameworks/BUILD.gn @@ -25,6 +25,7 @@ config("framework_config") { } ohos_shared_library("crypto_framework_lib") { + branch_protector_ret = "pac_ret" subsystem_name = "security" innerapi_tags = [ "platformsdk" ] part_name = "crypto_framework" diff --git a/frameworks/cj/BUILD.gn b/frameworks/cj/BUILD.gn index b096c56..849f114 100644 --- a/frameworks/cj/BUILD.gn +++ b/frameworks/cj/BUILD.gn @@ -16,6 +16,7 @@ import("//base/security/crypto_framework/frameworks/frameworks.gni") import("//build/ohos.gni") ohos_shared_library("cj_cryptoframework_ffi") { + branch_protector_ret = "pac_ret" include_dirs = [ "include" ] include_dirs += framework_inc_path diff --git a/frameworks/js/napi/crypto/BUILD.gn b/frameworks/js/napi/crypto/BUILD.gn index 4adb38c..5cd0655 100644 --- a/frameworks/js/napi/crypto/BUILD.gn +++ b/frameworks/js/napi/crypto/BUILD.gn @@ -16,6 +16,7 @@ import("//base/security/crypto_framework/frameworks/frameworks.gni") import("//build/ohos.gni") ohos_shared_library("cryptoframework_napi") { + branch_protector_ret = "pac_ret" subsystem_name = "security" part_name = "crypto_framework" relative_install_dir = "module/security" diff --git a/frameworks/native/BUILD.gn b/frameworks/native/BUILD.gn index 3281937..3bf85f5 100644 --- a/frameworks/native/BUILD.gn +++ b/frameworks/native/BUILD.gn @@ -16,6 +16,7 @@ import("//base/security/crypto_framework/frameworks/frameworks.gni") import("//build/ohos.gni") ohos_shared_library("ohcrypto") { + branch_protector_ret = "pac_ret" if (os_level == "standard") { sanitize = { cfi = true diff --git a/plugin/BUILD.gn b/plugin/BUILD.gn index fd6d724..3c3e765 100644 --- a/plugin/BUILD.gn +++ b/plugin/BUILD.gn @@ -26,6 +26,7 @@ config("plugin_config") { } ohos_shared_library("crypto_openssl_plugin_lib") { + branch_protector_ret = "pac_ret" subsystem_name = "security" innerapi_tags = [ "platformsdk_indirect" ] part_name = "crypto_framework" -- Gitee From a1414df7cc6cb63df78deccaa837dc9c1ee56162 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E9=9D=99?= Date: Fri, 30 Aug 2024 09:28:11 +0800 Subject: [PATCH 23/32] =?UTF-8?q?=E5=8A=A0=E8=A7=A3=E5=AF=86=E7=AE=97?= =?UTF-8?q?=E6=B3=95=E5=BA=93=E4=BB=A3=E7=A0=81=E6=A3=80=E8=A7=86=E9=97=AE?= =?UTF-8?q?=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: 王静 --- .../common/inc/openssl_common.h | 2 -- .../common/src/openssl_common.c | 22 --------------- .../cipher/src/cipher_rsa_openssl.c | 2 -- .../crypto_operation/md/src/md_openssl.c | 8 +++++- .../signature/src/ed25519_openssl.c | 12 ++------ .../signature/src/sm2_openssl.c | 13 ++------- .../src/rsa_asy_key_generator_openssl.c | 21 ++++++++++++++ test/unittest/src/crypto_common_cov_test.cpp | 28 ------------------- .../src/native/native_asym_key_test.cpp | 2 +- 9 files changed, 35 insertions(+), 75 deletions(-) diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index 7607bbe..a136084 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -52,8 +52,6 @@ void HcfPrintOpensslError(void); HcfResult GetOpensslPadding(int32_t padding, int32_t *opensslPadding); -int32_t GetRealPrimes(int32_t primesFlag); - bool IsBigEndian(void); HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest); diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index b054a34..a80d789 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -27,11 +27,6 @@ #include "params_parser.h" #include "utils.h" -#define PRIMES_2 2 -#define PRIMES_3 3 -#define PRIMES_4 4 -#define PRIMES_5 5 - #define HCF_OPENSSL_DIGEST_NONE_STR "NONE" #define HCF_OPENSSL_DIGEST_MD5_STR "MD5" #define HCF_OPENSSL_DIGEST_SM3_STR "SM3" @@ -418,23 +413,6 @@ HcfResult GetOpensslPadding(int32_t padding, int32_t *opensslPadding) } } -int32_t GetRealPrimes(int32_t primesFlag) -{ - switch (primesFlag) { - case HCF_OPENSSL_PRIMES_2: - return PRIMES_2; - case HCF_OPENSSL_PRIMES_3: - return PRIMES_3; - case HCF_OPENSSL_PRIMES_4: - return PRIMES_4; - case HCF_OPENSSL_PRIMES_5: - return PRIMES_5; - default: - LOGD("set default primes 2"); - return PRIMES_2; - } -} - bool IsBigEndian(void) { uint32_t *pointer = (uint32_t *)&ASCII_CODE_ZERO; diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c index d17899b..d567d0b 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_rsa_openssl.c @@ -72,7 +72,6 @@ static HcfResult DuplicateRsaFromKey(HcfKey *key, enum HcfCryptoMode opMode, RSA LOGD("[error] dup pub RSA fail."); return ret; } - LOGD("dup pub RSA success."); } else if (opMode == DECRYPT_MODE) { // dup will check if rsa is NULL ret = DuplicateRsa(((HcfOpensslRsaPriKey *)key)->sk, true, dupRsa); @@ -80,7 +79,6 @@ static HcfResult DuplicateRsaFromKey(HcfKey *key, enum HcfCryptoMode opMode, RSA LOGD("[error] dup pri RSA fail."); return ret; } - LOGD("dup pri RSA success."); } else { LOGD("[error] OpMode not match."); return HCF_INVALID_PARAMS; diff --git a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c index 323dbb9..ffcb32e 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -150,7 +150,7 @@ HcfResult OpensslMdSpiCreate(const char *opensslAlgoName, HcfMdSpi **spiObj) } OpensslMdSpiImpl *returnSpiImpl = (OpensslMdSpiImpl *)HcfMalloc(sizeof(OpensslMdSpiImpl), 0); if (returnSpiImpl == NULL) { - LOGE("Failed to allocate returnImpl memory!"); + LOGE("Failed to allocate MdSpiImpl memory!"); return HCF_ERR_MALLOC; } returnSpiImpl->ctx = OpensslEvpMdCtxNew(); @@ -160,6 +160,12 @@ HcfResult OpensslMdSpiCreate(const char *opensslAlgoName, HcfMdSpi **spiObj) return HCF_ERR_MALLOC; } const EVP_MD *mdfunc = OpensslGetMdAlgoFromString(opensslAlgoName); + if (mdfunc == NULL) { + LOGE("OpensslGetMdAlgoFromString failed!"); + OpensslEvpMdCtxFree(returnSpiImpl->ctx); + HcfFree(returnSpiImpl); + return HCF_ERR_CRYPTO_OPERATION; + } int32_t ret = OpensslEvpDigestInitEx(returnSpiImpl->ctx, mdfunc, NULL); if (ret != HCF_OPENSSL_SUCCESS) { LOGD("[error] Failed to init MD!"); diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/ed25519_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/ed25519_openssl.c index b0c6f3b..4c391c6 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/ed25519_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/ed25519_openssl.c @@ -111,19 +111,13 @@ static HcfResult EngineSignInit(HcfSignSpi *self, HcfParamsSpec *params, HcfPriK LOGE("Repeated initialization is not allowed."); return HCF_INVALID_PARAMS; } - EVP_PKEY *pKey = OpensslEvpPkeyDup(((HcfOpensslAlg25519PriKey *)privateKey)->pkey); - if (pKey == NULL) { - HcfPrintOpensslError(); - LOGD("[error] Dup pkey failed."); - return HCF_ERR_CRYPTO_OPERATION; - } - if (OpensslEvpDigestSignInit(impl->mdCtx, NULL, NULL, NULL, pKey) != HCF_OPENSSL_SUCCESS) { + + if (OpensslEvpDigestSignInit(impl->mdCtx, NULL, NULL, NULL, + ((HcfOpensslAlg25519PriKey *)privateKey)->pkey) != HCF_OPENSSL_SUCCESS) { HcfPrintOpensslError(); LOGD("[error] EVP_DigestSignInit failed."); - OpensslEvpPkeyFree(pKey); return HCF_ERR_CRYPTO_OPERATION; } - OpensslEvpPkeyFree(pKey); impl->status = INITIALIZED; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c index 458eb19..f2f57bc 100644 --- a/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/signature/src/sm2_openssl.c @@ -89,6 +89,7 @@ static void DestroySm2Sign(HcfObjectBase *self) HcfSignSpiSm2OpensslImpl *impl = (HcfSignSpiSm2OpensslImpl *)self; impl->digestAlg = NULL; if (impl->mdCtx != NULL) { + OpensslEvpPkeyCtxFree(OpensslEvpMdCtxGetPkeyCtx(impl->mdCtx)); OpensslEvpMdCtxFree(impl->mdCtx); impl->mdCtx = NULL; } @@ -110,6 +111,7 @@ static void DestroySm2Verify(HcfObjectBase *self) HcfVerifySpiSm2OpensslImpl *impl = (HcfVerifySpiSm2OpensslImpl *)self; impl->digestAlg = NULL; if (impl->mdCtx != NULL) { + OpensslEvpPkeyCtxFree(OpensslEvpMdCtxGetPkeyCtx(impl->mdCtx)); OpensslEvpMdCtxFree(impl->mdCtx); impl->mdCtx = NULL; } @@ -135,22 +137,13 @@ static HcfResult SetUserIdFromBlob(HcfBlob userId, EVP_MD_CTX *mdCtx) OpensslEvpMdCtxSetPkeyCtx(mdCtx, pKeyCtx); return HCF_SUCCESS; } - // deep copy from userId - uint8_t *opensslUserId = (uint8_t *)HcfMalloc(userId.len, 0); - if (opensslUserId == NULL) { - LOGE("Failed to allocate openssl userId data memory"); - return HCF_ERR_MALLOC; - } - (void)memcpy_s(opensslUserId, userId.len, userId.data, userId.len); - if (OpensslEvpPkeyCtxSet1Id(pKeyCtx, (const void*)opensslUserId, + if (OpensslEvpPkeyCtxSet1Id(pKeyCtx, (const void*)userId.data, userId.len) != HCF_OPENSSL_SUCCESS) { LOGD("[error] Set sm2 user id fail."); - HcfFree(opensslUserId); HcfPrintOpensslError(); return HCF_ERR_CRYPTO_OPERATION; } OpensslEvpMdCtxSetPkeyCtx(mdCtx, pKeyCtx); - HcfFree(opensslUserId); return HCF_SUCCESS; } 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 ed43ee8..fc31e1d 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 @@ -37,6 +37,10 @@ #define OPENSSL_RSA_KEYGEN_DEFAULT_PRIMES 2 #define MAX_KEY_SIZE 8192 #define MIN_KEY_SIZE 512 +#define PRIMES_2 2 +#define PRIMES_3 3 +#define PRIMES_4 4 +#define PRIMES_5 5 enum OpensslRsaKeySize { OPENSSL_RSA_KEY_SIZE_BY_SPEC = 0, @@ -875,6 +879,23 @@ ERR2: return ret; } +static int32_t GetRealPrimes(int32_t primesFlag) +{ + switch (primesFlag) { + case OPENSSL_RSA_PRIMES_SIZE_2: + return PRIMES_2; + case OPENSSL_RSA_PRIMES_SIZE_3: + return PRIMES_3; + case OPENSSL_RSA_PRIMES_SIZE_4: + return PRIMES_4; + case OPENSSL_RSA_PRIMES_SIZE_5: + return PRIMES_5; + default: + LOGD("set default primes 2"); + return PRIMES_2; + } +} + static HcfResult GenerateKeyPair(HcfAsyKeyGenSpiRsaParams *params, HcfKeyPair **keyPair) { // check input params is valid diff --git a/test/unittest/src/crypto_common_cov_test.cpp b/test/unittest/src/crypto_common_cov_test.cpp index e8b5672..d20e7cb 100644 --- a/test/unittest/src/crypto_common_cov_test.cpp +++ b/test/unittest/src/crypto_common_cov_test.cpp @@ -51,10 +51,6 @@ void CryptoCommonCovTest::SetUp() {} void CryptoCommonCovTest::TearDown() {} -constexpr uint32_t PRIMES_2 = 2; -constexpr uint32_t PRIMES_3 = 3; -constexpr uint32_t PRIMES_4 = 4; -constexpr uint32_t PRIMES_5 = 5; constexpr uint32_t BEGIN_POS = 1; constexpr uint32_t PARCEL_LENGTH = 1; constexpr uint32_t PARCEL_UINT_MAX = 0xffffffffU; @@ -171,30 +167,6 @@ HWTEST_F(CryptoCommonCovTest, CryptoCommonTest011, TestSize.Level0) EXPECT_NE(ret, HCF_SUCCESS); } -HWTEST_F(CryptoCommonCovTest, CryptoCommonTest012, TestSize.Level0) -{ - int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_2); - EXPECT_EQ(ret, PRIMES_2); -} - -HWTEST_F(CryptoCommonCovTest, CryptoCommonTest013, TestSize.Level0) -{ - int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_3); - EXPECT_EQ(ret, PRIMES_3); -} - -HWTEST_F(CryptoCommonCovTest, CryptoCommonTest014, TestSize.Level0) -{ - int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_4); - EXPECT_EQ(ret, PRIMES_4); -} - -HWTEST_F(CryptoCommonCovTest, CryptoCommonTest015, TestSize.Level0) -{ - int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_5); - EXPECT_EQ(ret, PRIMES_5); -} - HWTEST_F(CryptoCommonCovTest, CryptoCommonTest016, TestSize.Level0) { HcfResult ret = BigIntegerToBigNum(nullptr, nullptr); diff --git a/test/unittest/src/native/native_asym_key_test.cpp b/test/unittest/src/native/native_asym_key_test.cpp index 16e8351..fc0dea1 100644 --- a/test/unittest/src/native/native_asym_key_test.cpp +++ b/test/unittest/src/native/native_asym_key_test.cpp @@ -163,7 +163,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest004, TestSize.Level0) OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair); ASSERT_EQ(ret, CRYPTO_SUCCESS); - Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 }; + Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 }; ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_RSA_N_DATABLOB, &dataBlob); ASSERT_EQ(ret, CRYPTO_SUCCESS); -- Gitee From 51551bbaa926bdb45562b82d76dab4bade28753d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BB=AB=E5=9C=B0=E5=AE=81=E5=AE=81?= <756090608@qq.com> Date: Thu, 5 Sep 2024 11:02:00 +0800 Subject: [PATCH 24/32] =?UTF-8?q?mini=E5=B9=B3=E5=8F=B0=E6=96=B0=E5=A2=9E?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: guoxin <756090608@qq.com> --- BUILD.gn | 6 + bundle.json | 3 +- common/BUILD.gn | 63 ++++-- common/common.gni | 8 + common/inc/log.h | 11 +- frameworks/BUILD.gn | 86 +++++--- frameworks/crypto_operation/md.c | 11 + frameworks/crypto_operation/rand.c | 20 +- frameworks/frameworks.gni | 14 ++ frameworks/js/jsi/BUILD.gn | 45 ++++ frameworks/js/jsi/inc/jsi_api.h | 54 +++++ frameworks/js/jsi/inc/jsi_api_common.h | 43 ++++ frameworks/js/jsi/inc/jsi_api_errcode.h | 30 +++ frameworks/js/jsi/inc/jsi_list.h | 43 ++++ frameworks/js/jsi/inc/jsi_utils.h | 32 +++ frameworks/js/jsi/src/jsi_api.cpp | 39 ++++ frameworks/js/jsi/src/jsi_api_common.cpp | 31 +++ frameworks/js/jsi/src/jsi_api_errcode.cpp | 88 ++++++++ frameworks/js/jsi/src/jsi_list.cpp | 97 ++++++++ frameworks/js/jsi/src/jsi_md.cpp | 200 +++++++++++++++++ frameworks/js/jsi/src/jsi_rand.cpp | 160 ++++++++++++++ frameworks/js/jsi/src/jsi_utils.cpp | 91 ++++++++ frameworks/spi/rand_spi.h | 1 + plugin/BUILD.gn | 73 +++--- plugin/mbedtls_plugin/common/mbedtls_common.h | 30 +++ plugin/mbedtls_plugin/md/inc/mbedtls_md.h | 31 +++ plugin/mbedtls_plugin/md/src/mbedtls_md.c | 197 +++++++++++++++++ plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h | 29 +++ plugin/mbedtls_plugin/rand/src/mbedtls_rand.c | 208 ++++++++++++++++++ plugin/plugin.gni | 14 ++ 30 files changed, 1673 insertions(+), 85 deletions(-) create mode 100644 frameworks/js/jsi/BUILD.gn create mode 100644 frameworks/js/jsi/inc/jsi_api.h create mode 100644 frameworks/js/jsi/inc/jsi_api_common.h create mode 100644 frameworks/js/jsi/inc/jsi_api_errcode.h create mode 100644 frameworks/js/jsi/inc/jsi_list.h create mode 100644 frameworks/js/jsi/inc/jsi_utils.h create mode 100644 frameworks/js/jsi/src/jsi_api.cpp create mode 100644 frameworks/js/jsi/src/jsi_api_common.cpp create mode 100644 frameworks/js/jsi/src/jsi_api_errcode.cpp create mode 100644 frameworks/js/jsi/src/jsi_list.cpp create mode 100644 frameworks/js/jsi/src/jsi_md.cpp create mode 100644 frameworks/js/jsi/src/jsi_rand.cpp create mode 100644 frameworks/js/jsi/src/jsi_utils.cpp create mode 100644 plugin/mbedtls_plugin/common/mbedtls_common.h create mode 100644 plugin/mbedtls_plugin/md/inc/mbedtls_md.h create mode 100644 plugin/mbedtls_plugin/md/src/mbedtls_md.c create mode 100644 plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h create mode 100644 plugin/mbedtls_plugin/rand/src/mbedtls_rand.c diff --git a/BUILD.gn b/BUILD.gn index c7ff8f3..d8af064 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -24,6 +24,12 @@ group("crypto_framework_component") { "frameworks/native:ohcrypto", "plugin:crypto_openssl_plugin_lib", ] + } else if (os_level == "mini") { + deps = [ + "frameworks:crypto_framework_lib", + "frameworks/js/jsi:cryptoframework_jsi", + "plugin:crypto_mbedtls_plugin_lib", + ] } } diff --git a/bundle.json b/bundle.json index 3fe7bf3..e0f37ed 100644 --- a/bundle.json +++ b/bundle.json @@ -29,7 +29,8 @@ ], "features": [ "crypto_framework_enabled" ], "adapted_system_type": [ - "standard" + "standard", + "mini" ], "rom": "2048KB", "ram": "", diff --git a/common/BUILD.gn b/common/BUILD.gn index 965bd6c..98419d9 100644 --- a/common/BUILD.gn +++ b/common/BUILD.gn @@ -14,31 +14,46 @@ import("//base/security/crypto_framework/common/common.gni") import("//build/ohos.gni") -ohos_static_library("crypto_plugin_common") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - part_name = "crypto_framework" - include_dirs = crypto_framwork_common_inc_path - - sources = crypto_framwork_common_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_static_library("crypto_plugin_common") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = crypto_framwork_common_inc_path + + sources = crypto_framwork_common_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + defines = [ "HILOG_ENABLE" ] + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_common_lite") { + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = crypto_framwork_common_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - defines = [ "HILOG_ENABLE" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] - - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - ] + sources = crypto_framwork_common_files_lite + + defines = [ "MINI_HILOG_ENABLE" ] + + configs = [ "${product_path}:product_public_configs" ] + } } diff --git a/common/common.gni b/common/common.gni index 5507276..b6c1865 100644 --- a/common/common.gni +++ b/common/common.gni @@ -30,3 +30,11 @@ framework_common_util_files = [ ] crypto_framwork_common_files = framework_common_util_files + +crypto_framwork_common_files_lite = [ + "//base/security/crypto_framework/common/src/blob.c", + "//base/security/crypto_framework/common/src/utils.c", + "//base/security/crypto_framework/common/src/log.c", + "//base/security/crypto_framework/common/src/memory.c", + "//base/security/crypto_framework/common/src/object_base.c", +] diff --git a/common/inc/log.h b/common/inc/log.h index 0a18450..563a38e 100644 --- a/common/inc/log.h +++ b/common/inc/log.h @@ -19,7 +19,16 @@ #include #include -#ifdef HILOG_ENABLE +#ifdef MINI_HILOG_ENABLE + +#include "hiview_log.h" + +#define LOGD(fmt, ...) HILOG_DEBUG(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGI(fmt, ...) HILOG_INFO(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGW(fmt, ...) HILOG_WARN(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGE(fmt, ...) HILOG_ERROR(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) + +#elif HILOG_ENABLE enum HcfLogLevel { HCF_LOG_LEVEL_I, diff --git a/frameworks/BUILD.gn b/frameworks/BUILD.gn index c861451..9d86409 100644 --- a/frameworks/BUILD.gn +++ b/frameworks/BUILD.gn @@ -24,37 +24,67 @@ config("framework_config") { ] } -ohos_shared_library("crypto_framework_lib") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - innerapi_tags = [ "platformsdk" ] - part_name = "crypto_framework" - public_configs = [ ":framework_config" ] - include_dirs = framework_inc_path + crypto_framwork_common_inc_path - - sources = framework_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_shared_library("crypto_framework_lib") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + innerapi_tags = [ "platformsdk" ] + part_name = "crypto_framework" + public_configs = [ ":framework_config" ] + include_dirs = framework_inc_path + crypto_framwork_common_inc_path + + sources = framework_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + deps = [ + "../common:crypto_plugin_common", + "../plugin:crypto_openssl_plugin_lib", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_framework_lib") { + subsystem_name = "security" + part_name = "crypto_framework" + public_configs = [ ":framework_config" ] + include_dirs = framework_inc_lite_path + crypto_framwork_common_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] + sources = framework_lite_files - deps = [ - "../common:crypto_plugin_common", - "../plugin:crypto_openssl_plugin_lib", - ] + defines = [ + "CRYPTO_MBEDTLS", + "MINI_HILOG_ENABLE", + ] - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - ] + deps = [ + "../common:crypto_common_lite", + "../plugin:crypto_mbedtls_plugin_lib", + ] + + configs = [ "${product_path}:product_public_configs" ] + + cflags = [ + "--diag_suppress", + "Pe188,Pe186", + ] + } } diff --git a/frameworks/crypto_operation/md.c b/frameworks/crypto_operation/md.c index 0a921fd..888f3be 100644 --- a/frameworks/crypto_operation/md.c +++ b/frameworks/crypto_operation/md.c @@ -19,7 +19,11 @@ #include "sym_key.h" #include "md_spi.h" +#ifdef CRYPTO_MBEDTLS +#include "mbedtls_md.h" +#else #include "md_openssl.h" +#endif #include "log.h" #include "config.h" @@ -43,6 +47,12 @@ typedef struct { } HcfMdAbility; static const HcfMdAbility MD_ABILITY_SET[] = { +#ifdef CRYPTO_MBEDTLS + { "SHA1", MbedtlsMdSpiCreate }, + { "SHA256", MbedtlsMdSpiCreate }, + { "SHA512", MbedtlsMdSpiCreate }, + { "MD5", MbedtlsMdSpiCreate }, +#else { "SHA1", OpensslMdSpiCreate }, { "SHA224", OpensslMdSpiCreate }, { "SHA256", OpensslMdSpiCreate }, @@ -50,6 +60,7 @@ static const HcfMdAbility MD_ABILITY_SET[] = { { "SHA512", OpensslMdSpiCreate }, { "MD5", OpensslMdSpiCreate }, { "SM3", OpensslMdSpiCreate }, +#endif }; static const char *GetMdClass(void) diff --git a/frameworks/crypto_operation/rand.c b/frameworks/crypto_operation/rand.c index 99018ad..0f4227d 100644 --- a/frameworks/crypto_operation/rand.c +++ b/frameworks/crypto_operation/rand.c @@ -18,7 +18,11 @@ #include #include #include "rand_spi.h" +#ifdef CRYPTO_MBEDTLS +#include "mbedtls_rand.h" +#else #include "rand_openssl.h" +#endif #include "log.h" #include "config.h" #include "memory.h" @@ -40,15 +44,19 @@ typedef struct { HcfRandSpiCreateFunc createSpiFunc; } HcfRandAbility; -static const HcfRandAbility RAND_ABILITY_SET[] = { - { "OpensslRand", HcfRandSpiCreate } -}; - static const char *GetRandClass(void) { return "Rand"; } +static const HcfRandAbility RAND_ABILITY_SET[] = { +#ifdef CRYPTO_MBEDTLS + { "MbedtlsRand", MbedtlsRandSpiCreate } +#else + { "OpensslRand", HcfRandSpiCreate } +#endif +}; + static HcfRandSpiCreateFunc FindAbility(const char *algoName) { for (uint32_t i = 0; i < (sizeof(RAND_ABILITY_SET) / sizeof(RAND_ABILITY_SET[0])); i++) { @@ -127,7 +135,11 @@ HcfResult HcfRandCreate(HcfRand **random) LOGE("Invalid input params while creating rand!"); return HCF_INVALID_PARAMS; } +#ifdef CRYPTO_MBEDTLS + HcfRandSpiCreateFunc createSpiFunc = FindAbility("MbedtlsRand"); +#else HcfRandSpiCreateFunc createSpiFunc = FindAbility("OpensslRand"); +#endif if (createSpiFunc == NULL) { LOGE("Algo not supported!"); return HCF_NOT_SUPPORT; diff --git a/frameworks/frameworks.gni b/frameworks/frameworks.gni index 623a379..957383a 100644 --- a/frameworks/frameworks.gni +++ b/frameworks/frameworks.gni @@ -65,3 +65,17 @@ framework_files = framework_cipher_files + framework_key_files + framework_mac_files + framework_rand_files + framework_md_files + framework_kdf_files + framework_sm2_crypto_util_files + +framework_inc_lite_path = [ + "${base_path}/interfaces/innerkits/algorithm_parameter", + "${base_path}/interfaces/innerkits/common", + "${base_path}/interfaces/innerkits/crypto_operation", + "${base_path}/interfaces/innerkits/key", + "${base_path}/common/inc", + "${plugin_path}/mbedtls_plugin/common", + "${plugin_path}/mbedtls_plugin/md/inc", + "${plugin_path}/mbedtls_plugin/rand/inc", + "${framework_path}/spi", +] + +framework_lite_files = framework_rand_files + framework_md_files diff --git a/frameworks/js/jsi/BUILD.gn b/frameworks/js/jsi/BUILD.gn new file mode 100644 index 0000000..6ac9a4c --- /dev/null +++ b/frameworks/js/jsi/BUILD.gn @@ -0,0 +1,45 @@ +# Copyright (C) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//base/security/crypto_framework/common/common.gni") +import("//base/security/crypto_framework/frameworks/frameworks.gni") +import("//build/lite/config/component/lite_component.gni") +import("//build/ohos.gni") + +ohos_static_library("cryptoframework_jsi") { + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = [ "inc" ] + include_dirs += framework_inc_path + include_dirs += [ + "../../../../../hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite", + ] + + sources = [ + "src/jsi_api.cpp", + "src/jsi_api_common.cpp", + "src/jsi_api_errcode.cpp", + "src/jsi_list.cpp", + "src/jsi_md.cpp", + "src/jsi_rand.cpp", + "src/jsi_utils.cpp", + ] + defines = [ "MINI_HILOG_ENABLE" ] + + deps = [ + "../../../common:crypto_common_lite", + "../../../frameworks:crypto_framework_lib", + ] + + configs = [ "${product_path}:product_public_configs" ] +} diff --git a/frameworks/js/jsi/inc/jsi_api.h b/frameworks/js/jsi/inc/jsi_api.h new file mode 100644 index 0000000..7234925 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JSI_API_H +#define JSI_API_H + +#include "jsi/jsi.h" +#include "jsi/jsi_types.h" + +namespace OHOS { +namespace ACELite { +class CryptoFrameworkLiteModule final : public MemoryHeap { +public: + CryptoFrameworkLiteModule() {} + ~CryptoFrameworkLiteModule() {}; + + static JSIValue CreateMd(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue CreateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static void OnDestroy(void); + +private: + // Md + static JSIValue Update(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue UpdateSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Digest(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + + // Random + static JSIValue GenerateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue GenerateRandomSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + + static void MdDestroy(void); + static void RandomDestroy(void); +}; + +void InitCryptoFrameworkModule(JSIValue exports); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_H diff --git a/frameworks/js/jsi/inc/jsi_api_common.h b/frameworks/js/jsi/inc/jsi_api_common.h new file mode 100644 index 0000000..e80dffb --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api_common.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JSI_API_COMMON_H +#define JSI_API_COMMON_H + +#include "jsi.h" +#include "jsi/jsi_types.h" + +#include "md.h" +#include "rand.h" +#include "object_base.h" + +namespace OHOS { +namespace ACELite { + +typedef enum { + JSI_ALG_MD = 1, + JSI_ALG_RAND = 2, + JSI_ALG_MAX +} LiteAlgType; + +#define ARRAY_MAX_SIZE 2 +#define ARRAY_INDEX_ZERO 0 +#define ARRAY_INDEX_ONE 1 + +void JsiAsyncCallback(const JSIValue thisVal, JSIValue args, const JSIValue *params, uint8_t paramsNum); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_COMMON_H diff --git a/frameworks/js/jsi/inc/jsi_api_errcode.h b/frameworks/js/jsi/inc/jsi_api_errcode.h new file mode 100644 index 0000000..6563a42 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api_errcode.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JSI_API_ERRCODE_H +#define JSI_API_ERRCODE_H + +#include "jsi/jsi.h" +#include "jsi/jsi_types.h" + +namespace OHOS { +namespace ACELite { + +void CallbackErrorCodeOrDataResult(const JSIValue thisVal, const JSIValue args, int32_t errCode, const JSIValue data); +JSIValue ThrowErrorCodeResult(int32_t errorCode); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_ERRCODE_H diff --git a/frameworks/js/jsi/inc/jsi_list.h b/frameworks/js/jsi/inc/jsi_list.h new file mode 100644 index 0000000..06d2537 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_list.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JSI_LIST_H +#define JSI_LIST_H + +#include "los_list.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +typedef struct { + LiteAlgType type; + LOS_DL_LIST *objListHeader; +} ListInfo; + +typedef struct { + LOS_DL_LIST listNode; + uint32_t objAddr; +} ObjList; + +void ListObjInit(LiteAlgType type); +HcfResult ListAddObjNode(LiteAlgType type, uint32_t addAddr); +void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr); +void ListDestroy(LiteAlgType type); + +} // namespace ACELite +} // namespace OHOS + +#endif // JSI_LIST_H diff --git a/frameworks/js/jsi/inc/jsi_utils.h b/frameworks/js/jsi/inc/jsi_utils.h new file mode 100644 index 0000000..e3ee876 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_utils.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JSI_UTILS_H +#define JSI_UTILS_H + +#include + +#include "blob.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob); +JSIValue ConstructJSIReturnResult(const HcfBlob *blob); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_UTILS_H diff --git a/frameworks/js/jsi/src/jsi_api.cpp b/frameworks/js/jsi/src/jsi_api.cpp new file mode 100644 index 0000000..3312a0b --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_api.h" +#include "jsi_list.h" +#include "jsi.h" + +namespace OHOS { +namespace ACELite { + +void InitCryptoFrameworkModule(JSIValue exports) +{ + JSI::SetModuleAPI(exports, "createMd", CryptoFrameworkLiteModule::CreateMd); + JSI::SetModuleAPI(exports, "createRandom", CryptoFrameworkLiteModule::CreateRandom); + JSI::SetOnDestroy(exports, CryptoFrameworkLiteModule::OnDestroy); + ListObjInit(JSI_ALG_MD); + ListObjInit(JSI_ALG_RAND); +} + +void CryptoFrameworkLiteModule::OnDestroy(void) +{ + RandomDestroy(); + MdDestroy(); +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_api_common.cpp b/frameworks/js/jsi/src/jsi_api_common.cpp new file mode 100644 index 0000000..36db623 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api_common.cpp @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_api_common.h" +#include "jsi_api_errcode.h" + +namespace OHOS { +namespace ACELite { + +void JsiAsyncCallback(const JSIValue thisVal, const JSIValue args, const JSIValue *params, uint8_t paramsNum) +{ + JSIValue para[ARRAY_MAX_SIZE] = { params[ARRAY_INDEX_ZERO], params[ARRAY_INDEX_ONE] }; + JSI::CallFunction(args, thisVal, para, paramsNum); + JSI::ReleaseValue(para[ARRAY_INDEX_ZERO]); + JSI::ReleaseValue(para[ARRAY_INDEX_ONE]); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_api_errcode.cpp b/frameworks/js/jsi/src/jsi_api_errcode.cpp new file mode 100644 index 0000000..f9707bb --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api_errcode.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_api_errcode.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +constexpr uint32_t JSI_ERR_CODE_DEFAULT_ERR = 0; +constexpr uint32_t JSI_ERR_CODE_OUT_OF_MEMORY = 17620001; +constexpr uint32_t JSI_ERR_CODE_RUNTIME_ERROR = 17620002; +constexpr uint32_t JSI_ERR_CODE_CRYPTO_OPERATION = 17630001; + +typedef struct { + uint32_t errorCode; + const char *errorMsg; +} JsiErrMsg; + +static JsiErrMsg g_errMsg[] = { + { JSI_ERR_CODE_PARAM_CHECK_FAILED, "Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;\ + 2. Incorrect parameter types; 3. Parameter verification failed." }, + { JSI_ERR_CODE_NOT_SUPPORTED, "Capability not supported. Failed to call the API due to limited device\ + capabilities." }, + { JSI_ERR_CODE_OUT_OF_MEMORY, "memory error." }, + { JSI_ERR_CODE_RUNTIME_ERROR, "runtime error." }, + { JSI_ERR_CODE_CRYPTO_OPERATION, "crypto operation error." }, +}; + +static uint32_t GetJsiErrValueByErrCode(HcfResult errCode) +{ + switch (errCode) { + case HCF_INVALID_PARAMS: + return JSI_ERR_CODE_PARAM_CHECK_FAILED; + case HCF_NOT_SUPPORT: + return JSI_ERR_CODE_NOT_SUPPORTED; + case HCF_ERR_MALLOC: + return JSI_ERR_CODE_OUT_OF_MEMORY; + case HCF_ERR_NAPI: + return JSI_ERR_CODE_RUNTIME_ERROR; + case HCF_ERR_CRYPTO_OPERATION: + return JSI_ERR_CODE_CRYPTO_OPERATION; + default: + return JSI_ERR_CODE_DEFAULT_ERR; + } +} + +JSIValue ThrowErrorCodeResult(int32_t errCode) +{ + for (uint32_t index = 0; index < sizeof(g_errMsg) / sizeof(g_errMsg[0]); index++) { + if (g_errMsg[index].errorCode == GetJsiErrValueByErrCode((HcfResult)errCode)) { + return JSI::CreateErrorWithCode(g_errMsg[index].errorCode, g_errMsg[index].errorMsg); + } + } + + return JSI::CreateUndefined(); +} + +void CallbackErrorCodeOrDataResult(const JSIValue thisVal, const JSIValue args, int32_t errCode, const JSIValue data) +{ + for (uint32_t index = 0; index < sizeof(g_errMsg) /sizeof(g_errMsg[0]); index++) { + if (g_errMsg[index].errorCode == GetJsiErrValueByErrCode((HcfResult)errCode)) { + JSIValue errObj = JSI::CreateObject(); + JSI::SetNumberProperty(errObj, "code", g_errMsg[index].errorCode); + JSI::SetStringProperty(errObj, "message", g_errMsg[index].errorMsg); + JSIValue params[ARRAY_MAX_SIZE] = { errObj, data }; + JsiAsyncCallback(thisVal, args, params, ARRAY_MAX_SIZE); + return; + } + } + JSIValue params[ARRAY_MAX_SIZE] = { JSI::CreateUndefined(), data }; + JsiAsyncCallback(thisVal, args, params, ARRAY_MAX_SIZE); +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_list.cpp b/frameworks/js/jsi/src/jsi_list.cpp new file mode 100644 index 0000000..14343b0 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_list.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_list.h" +#include "memory.h" + +static LOS_DL_LIST g_mdObjListHeader = { 0 }; +static LOS_DL_LIST g_randObjListHeader = { 0 }; + +namespace OHOS { +namespace ACELite { + +ListInfo g_listMap[] = { + { JSI_ALG_MD, &g_mdObjListHeader }, + { JSI_ALG_RAND, &g_randObjListHeader } +}; + +LOS_DL_LIST *GetListHeader(LiteAlgType type) +{ + for (uint32_t index = 0; index < sizeof(g_listMap) / sizeof(g_listMap[0]); index++) { + if (type == g_listMap[index].type) { + return g_listMap[index].objListHeader; + } + } + + return nullptr; +} + +void ListObjInit(LiteAlgType type) +{ + LOS_ListInit(GetListHeader(type)); +} + +HcfResult ListAddObjNode(LiteAlgType type, uint32_t addAddr) +{ + ObjList *obj = (ObjList *)HcfMalloc(sizeof(ObjList), 0); + if (obj == nullptr) { + return HCF_ERR_MALLOC; + } + obj->objAddr = addAddr; + + if (GetListHeader(type)->pstNext == nullptr) { + LOS_ListInit(GetListHeader(type)); + } + LOS_ListAdd(GetListHeader(type), &(obj->listNode)); + + return HCF_SUCCESS; +} + +void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr) +{ + ObjList *obj = nullptr; + ObjList *objNext = nullptr; + LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(obj, objNext, GetListHeader(type), ObjList, listNode) { + if (obj == nullptr) { + return; + } + if ((obj->objAddr != 0) && (obj->objAddr == deleteAddr)) { + LOS_ListDelete(&(obj->listNode)); + HcfObjDestroy((void *)deleteAddr); + obj->objAddr = 0; + HcfFree(obj); + obj = nullptr; + } + } +} + +void ListDestroy(LiteAlgType type) +{ + ObjList *obj = nullptr; + ObjList *objNext = nullptr; + uint32_t i = 0; + LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(obj, objNext, GetListHeader(type), ObjList, listNode) { + if (obj == nullptr) { + return; + } + LOS_ListDelete(&(obj->listNode)); + HcfObjDestroy((void *)(obj->objAddr)); + HcfFree(obj); + obj = nullptr; + } +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_md.cpp b/frameworks/js/jsi/src/jsi_md.cpp new file mode 100644 index 0000000..0d0d361 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_md.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_api.h" +#include "jsi_api_common.h" +#include "jsi_api_errcode.h" +#include "jsi_utils.h" +#include "jsi_list.h" +#include "securec.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +JSIValue CryptoFrameworkLiteModule::CreateMd(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("CreateMd args is err!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + char *alg = JSI::ValueToString(args[0]); + if (alg == nullptr) { + LOGE("Update alg is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + HcfMd *mdObj = nullptr; + HcfResult res = HcfMdCreate(reinterpret_cast(alg), &mdObj); + if (res != HCF_SUCCESS) { + LOGE("CreateMd is mdObj err res %d!", res); + return ThrowErrorCodeResult(res); + } + res = ListAddObjNode(JSI_ALG_MD, (uint32_t)mdObj); + if (res != HCF_SUCCESS) { + LOGE("md add node is %d err!", res); + HcfObjDestroy((void *)mdObj); + return ThrowErrorCodeResult(res); + } + + JSIValue serviceObj = JSI::CreateObject(); + JSIValue update = JSI::CreateFunction(Update); + JSIValue updateSync = JSI::CreateFunction(UpdateSync); + JSIValue digest = JSI::CreateFunction(Digest); + JSIValue digestSync = JSI::CreateFunction(DigestSync); + JSIValue getMdLength = JSI::CreateFunction(GetMdLength); + JSI::SetNamedProperty(serviceObj, "update", update); + JSI::SetNamedProperty(serviceObj, "updateSync", updateSync); + JSI::SetNamedProperty(serviceObj, "digest", digest); + JSI::SetNamedProperty(serviceObj, "digestSync", digestSync); + JSI::SetNamedProperty(serviceObj, "getMdLength", getMdLength); + JSI::SetNumberProperty(serviceObj, "mdObj", (double)(uint32_t)mdObj); + JSI::ReleaseValueList(update, updateSync, digest, digestSync, getMdLength, ARGS_END); + + return serviceObj; +} + +JSIValue CryptoFrameworkLiteModule::Update(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE)) { + LOGE("Update args is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("Update mdObj is null!!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob inBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Update inBlob is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + errCode = mdObj->update(mdObj, &inBlob); + HcfBlobDataClearAndFree(&inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Update errCode not is success!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], errCode, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_SUCCESS, JSI::CreateNull()); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::UpdateSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("UpdateSync args is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("UpdateSync mdObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob inBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("UpdateSync inBlob is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + errCode = mdObj->update(mdObj, &inBlob); + HcfBlobDataClearAndFree(&inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("UpdateSync update ret is error!"); + } + + return ThrowErrorCodeResult(errCode); +} + +JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("Digest args is err or mdObj nullptr!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("Digest mdObj is null!!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = mdObj->doFinal(mdObj, &outBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Digest errCode not is success!"); + HcfBlobDataClearAndFree(&outBlob); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], errCode, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + JSIValue outVlaue = ConstructJSIReturnResult(&outBlob); + CallbackErrorCodeOrDataResult(thisVal, args[0], errCode, outVlaue); + HcfBlobDataClearAndFree(&outBlob); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("DigestSync mdObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = mdObj->doFinal(mdObj, &outBlob); + if (errCode != HCF_SUCCESS) { + LOGE("DigestSync errCode not is success!"); + HcfBlobDataClearAndFree(&outBlob); + return ThrowErrorCodeResult(errCode); + } + + JSIValue mdSyncData = ConstructJSIReturnResult(&outBlob); + HcfBlobDataClearAndFree(&outBlob); + + return mdSyncData; +} + +JSIValue CryptoFrameworkLiteModule::GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("GetMdLength mdObj is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + return JSI::CreateNumber(mdObj->getMdLength(mdObj)); +} + +void CryptoFrameworkLiteModule::MdDestroy(void) +{ + ListDestroy(JSI_ALG_MD); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_rand.cpp b/frameworks/js/jsi/src/jsi_rand.cpp new file mode 100644 index 0000000..c1059e0 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_rand.cpp @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_api.h" +#include "jsi_api_common.h" +#include "jsi_api_errcode.h" +#include "jsi_utils.h" +#include "jsi_list.h" +#include "securec.h" +#include "jsi.h" +#include "jsi_types.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +JSIValue CryptoFrameworkLiteModule::CreateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = nullptr; + HcfResult res = HcfRandCreate(&randObj); + if (res != HCF_SUCCESS) { + LOGE("CreateRandom is randObj err %d!", res); + return ThrowErrorCodeResult(res); + } + + res = ListAddObjNode(JSI_ALG_RAND, (uint32_t)randObj); + if (res != HCF_SUCCESS) { + LOGE("rand add node is %d err!", res); + HcfObjDestroy((void *)randObj); + return ThrowErrorCodeResult(res); + } + + JSIValue serviceObj = JSI::CreateObject(); + JSIValue generateRandom = JSI::CreateFunction(GenerateRandom); + JSIValue generateRandomSync = JSI::CreateFunction(GenerateRandomSync); + JSIValue setSeed = JSI::CreateFunction(SetSeed); + + JSI::SetNamedProperty(serviceObj, "generateRandom", generateRandom); + JSI::SetNamedProperty(serviceObj, "generateRandomSync", generateRandomSync); + JSI::SetNamedProperty(serviceObj, "setSeed", setSeed); + JSI::SetNumberProperty(serviceObj, "randObj", (double)(uint32_t)randObj); + JSI::ReleaseValueList(generateRandom, generateRandomSync, setSeed, ARGS_END); + + return serviceObj; +} + +JSIValue CryptoFrameworkLiteModule::GenerateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE) || (args[ARRAY_INDEX_ONE] == nullptr)) { + LOGE("GenerateRandom params is err!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + + int32_t numBytes = (int32_t)JSI::ValueToNumber(args[0]); + if (numBytes <= 0) { + LOGE("GenerateRandom numBytes too small!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfBlob randBlob = { .data = nullptr, .len = 0 }; + HcfResult res = randObj->generateRandom(randObj, numBytes, &randBlob); + if (res != HCF_SUCCESS) { + LOGE("GenerateRandom randObj not is success!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], res, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + + JSIValue outVlaue = ConstructJSIReturnResult(&randBlob); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], res, outVlaue); + HcfBlobDataClearAndFree(&randBlob); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("GenerateRandomSync params is err"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + int32_t numBytes = (int32_t)JSI::ValueToNumber(args[0]); + if (numBytes <= 0) { + LOGE("GenerateRandomSync numBytes too small!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + HcfBlob randBlob = { .data = nullptr, .len = 0 }; + HcfResult res = randObj->generateRandom(randObj, numBytes, &randBlob); + if (res != HCF_SUCCESS) { + LOGE("GenerateRandomSync randObj not is success!"); + HcfBlobDataClearAndFree(&randBlob); + return ThrowErrorCodeResult(res); + } + JSIValue randomSyncData = ConstructJSIReturnResult(&randBlob); + HcfBlobDataClearAndFree(&randBlob); + + return randomSyncData; +} + +JSIValue CryptoFrameworkLiteModule::SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("SetSeed randObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("SetSeed params is null"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob seedBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &seedBlob); + if (errCode != HCF_SUCCESS) { + LOGE("SetSeed seedBlob is null!"); + return ThrowErrorCodeResult(HCF_ERR_MALLOC); + } + + HcfResult res = randObj->setSeed(randObj, &seedBlob); + HcfBlobDataClearAndFree(&seedBlob); + if (res != HCF_SUCCESS) { + LOGE("setSeed randObj not is success!"); + return ThrowErrorCodeResult(res); + } + + return ThrowErrorCodeResult(HCF_SUCCESS); +} + +void CryptoFrameworkLiteModule::RandomDestroy(void) +{ + ListDestroy(JSI_ALG_RAND); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_utils.cpp b/frameworks/js/jsi/src/jsi_utils.cpp new file mode 100644 index 0000000..0cbbb46 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_utils.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jsi_utils.h" +#include "jsi.h" +#include "jsi_types.h" +#include "memory.h" +#include "securec.h" +#include "utils.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob) +{ + if (!JSI::ValueIsTypedArray(value) || (blob == nullptr)) { + LOGE("value is not a typed array!"); + return HCF_INVALID_PARAMS; + } + TypedArrayType arrayType; + size_t arraySize = 0; + size_t byteOffset = 0; + JSIValue arrayBuffer = nullptr; + uint8_t *dataArray; + HcfResult ret = HCF_SUCCESS; + do { + dataArray = JSI::GetTypedArrayInfo(value, arrayType, arraySize, arrayBuffer, byteOffset); + if (dataArray == nullptr) { + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + if (arrayType != TypedArrayType::JSI_UINT8_ARRAY) { + LOGE("value is not a uint8 array"); + ret = HCF_INVALID_PARAMS; + break; + } + blob->data = (uint8_t *)HcfMalloc(arraySize, 0); + if (blob->data == nullptr) { + ret = HCF_ERR_MALLOC; + break; + } + memcpy_s(blob->data, arraySize, dataArray + byteOffset, arraySize); + blob->len = arraySize; + } while (0); + if (arrayBuffer != nullptr) { + JSI::ReleaseValue(arrayBuffer); + arrayBuffer = nullptr; + } + return ret; +} + +JSIValue ConstructJSIReturnResult(const HcfBlob *blob) +{ + JSIValue res; + do { + res = JSI::CreateObject(); + if (res == nullptr) { + break; + } + if (blob->data != nullptr) { + uint8_t *arrayBuffer = nullptr; + JSIValue buffer = JSI::CreateArrayBuffer(blob->len, arrayBuffer); + if (arrayBuffer == nullptr) { + LOGE("create jsi array buffer failed"); + JSI::ReleaseValue(buffer); + return res; + } + (void)memcpy_s(arrayBuffer, blob->len, blob->data, blob->len); + JSIValue typedArray = JSI::CreateTypedArray(TypedArrayType::JSI_UINT8_ARRAY, blob->len, buffer, 0); + JSI::ReleaseValue(buffer); + JSI::SetNamedProperty(res, "data", typedArray); + } + } while (0); + return res; +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 8b554c6..166950f 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -22,6 +22,7 @@ #include "object_base.h" #define OPENSSL_RAND_ALGORITHM "CTR_DRBG" +#define MBEDTLS_RAND_ALGORITHM "CTR_DRBG_MBEDTLS" typedef struct HcfRandSpi HcfRandSpi; diff --git a/plugin/BUILD.gn b/plugin/BUILD.gn index 3c3e765..08b689c 100644 --- a/plugin/BUILD.gn +++ b/plugin/BUILD.gn @@ -25,36 +25,55 @@ config("plugin_config") { ] } -ohos_shared_library("crypto_openssl_plugin_lib") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - innerapi_tags = [ "platformsdk_indirect" ] - part_name = "crypto_framework" - public_configs = [ ":plugin_config" ] - include_dirs = plugin_inc_path + crypto_framwork_common_inc_path - - sources = plugin_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_shared_library("crypto_openssl_plugin_lib") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + innerapi_tags = [ "platformsdk_indirect" ] + part_name = "crypto_framework" + public_configs = [ ":plugin_config" ] + include_dirs = plugin_inc_path + crypto_framwork_common_inc_path + + sources = plugin_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + deps = [ "//base/security/crypto_framework/common:crypto_plugin_common" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "openssl:libcrypto_shared", + ] + defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_mbedtls_plugin_lib") { + subsystem_name = "security" + part_name = "crypto_framework" + public_configs = [ ":plugin_config" ] + include_dirs = crypto_framwork_common_inc_path + mbedtls_plugin_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] + sources = mbedtls_plugin_files - deps = [ "//base/security/crypto_framework/common:crypto_plugin_common" ] + defines = [ "MINI_HILOG_ENABLE" ] - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - "openssl:libcrypto_shared", - ] - defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] + deps = [ "//base/security/crypto_framework/common:crypto_common_lite" ] + + configs = [ "${product_path}:product_public_configs" ] + } } diff --git a/plugin/mbedtls_plugin/common/mbedtls_common.h b/plugin/mbedtls_plugin/common/mbedtls_common.h new file mode 100644 index 0000000..702a39e --- /dev/null +++ b/plugin/mbedtls_plugin/common/mbedtls_common.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MBEDTLS_COMMON_H +#define MBEDTLS_COMMON_H + +#include +#include + +#include "result.h" +#include "utils.h" + +#define HCF_MBEDTLS_SUCCESS 0 +#define HCF_MBEDTLS_FAILURE (-1) +#define HCF_BITS_PER_BYTE 8 +#define HCF_EVP_MAX_MD_SIZE 64 + +#endif diff --git a/plugin/mbedtls_plugin/md/inc/mbedtls_md.h b/plugin/mbedtls_plugin/md/inc/mbedtls_md.h new file mode 100644 index 0000000..cbd66da --- /dev/null +++ b/plugin/mbedtls_plugin/md/inc/mbedtls_md.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef HCF_MBEDTLS_MD_H +#define HCF_MBEDTLS_MD_H + +#include "md_spi.h" + +#define HCF_MBEDTLS_INVALID_MD_LEN 0 + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult MbedtlsMdSpiCreate(const char *mbedtlsAlgoName, HcfMdSpi **spiObj); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/plugin/mbedtls_plugin/md/src/mbedtls_md.c b/plugin/mbedtls_plugin/md/src/mbedtls_md.c new file mode 100644 index 0000000..73a5fd6 --- /dev/null +++ b/plugin/mbedtls_plugin/md/src/mbedtls_md.c @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mbedtls_md.h" + +#include "mbedtls_common.h" +#include "mbedtls/md.h" +#include "securec.h" +#include "log.h" +#include "memory.h" +#include "config.h" +#include "utils.h" + +typedef struct { + HcfMdSpi base; + mbedtls_md_context_t *ctx; + char mbedtlsAlgoName[HCF_MAX_ALGO_NAME_LEN]; +} MbedtlsMdSpiImpl; + +mbedtls_md_context_t *MbedtlsEvpMdCtxNew(void) +{ + return (mbedtls_md_context_t *)HcfMalloc(sizeof(mbedtls_md_context_t), 0); +} + +void MbedtlsEvpMdCtxFree(mbedtls_md_context_t *ctx) +{ + HcfFree(ctx); +} + +static const char *MbedtlsGetMdClass(void) +{ + return "MbedtlsMd"; +} + +static mbedtls_md_context_t *MbedtlsGetMdCtx(HcfMdSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, MbedtlsGetMdClass())) { + LOGE("Class is not match."); + return NULL; + } + + return ((MbedtlsMdSpiImpl *)self)->ctx; +} + +static HcfResult MbedtlsEngineUpdateMd(HcfMdSpi *self, HcfBlob *input) +{ + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGD("The CTX is NULL!"); + return HCF_INVALID_PARAMS; + } + int32_t ret = mbedtls_md_update(ctx, (const unsigned char *)input->data, input->len); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("EVP_DigestUpdate return error %d!", ret); + return HCF_ERR_CRYPTO_OPERATION; + } + + return HCF_SUCCESS; +} + +static HcfResult MbedtlsEngineDoFinalMd(HcfMdSpi *self, HcfBlob *output) +{ + if ((self == NULL) || (output == NULL)) { + LOGE("The input self ptr is NULL!"); + return HCF_INVALID_PARAMS; + } + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGE("The CTX is NULL!"); + return HCF_INVALID_PARAMS; + } + unsigned char outputBuf[HCF_EVP_MAX_MD_SIZE] = { 0 }; + uint8_t outputLen = mbedtls_md_get_size(mbedtls_md_info_from_ctx(ctx)); + if (outputLen == 0) { + LOGD("Failed to md get size is 0!"); + return HCF_ERR_CRYPTO_OPERATION; + } + int32_t ret = mbedtls_md_finish(ctx, outputBuf); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("Failed to md finish return error is %d!", ret); + return HCF_ERR_CRYPTO_OPERATION; + } + output->data = (uint8_t *)HcfMalloc(outputLen, 0); + if (output->data == NULL) { + LOGE("Failed to allocate output->data memory!"); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); + output->len = outputLen; + + return HCF_SUCCESS; +} + +static uint32_t MbedtlsEngineGetMdLength(HcfMdSpi *self) +{ + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGD("The CTX is NULL!"); + return HCF_MBEDTLS_INVALID_MD_LEN; + } + uint8_t outputLen = mbedtls_md_get_size(mbedtls_md_info_from_ctx(ctx)); + if ((outputLen == 0) || (outputLen > HCF_EVP_MAX_MD_SIZE)) { + LOGD("Get the overflow path length is %d in mbedtls!", outputLen); + return HCF_MBEDTLS_INVALID_MD_LEN; + } + + return outputLen; +} + +static void MbedtlsDestroyMd(HcfObjectBase *self) +{ + if (self == NULL) { + LOGE("The input self ptr is NULL!"); + return; + } + if (!HcfIsClassMatch(self, MbedtlsGetMdClass())) { + LOGE("Class is not match."); + return; + } + if (MbedtlsGetMdCtx((HcfMdSpi *)self) != NULL) { + mbedtls_md_free(MbedtlsGetMdCtx((HcfMdSpi *)self)); + MbedtlsEvpMdCtxFree(MbedtlsGetMdCtx((HcfMdSpi *)self)); + } + HcfFree(self); +} + +typedef struct { + char *mdAlg; + mbedtls_md_type_t mdType; +} MdAlgTypeMap; + +static MdAlgTypeMap g_mdAlgMap[] = { + { "MD5", MBEDTLS_MD_MD5 }, + { "SHA1", MBEDTLS_MD_SHA1 }, + { "SHA256", MBEDTLS_MD_SHA256 }, + { "SHA512", MBEDTLS_MD_SHA512 }, +}; + +int MbedtlsEvpDigestInitEx(mbedtls_md_context_t *ctx, const char *mbedtlsAlgoName) +{ + for (uint32_t index = 0; index < sizeof(g_mdAlgMap) / sizeof(g_mdAlgMap[0]); index++) { + if (strcmp(g_mdAlgMap[index].mdAlg, mbedtlsAlgoName) == 0) { + mbedtls_md_init(ctx); + mbedtls_md_setup(ctx, mbedtls_md_info_from_type(g_mdAlgMap[index].mdType), 0); + mbedtls_md_starts(ctx); + return HCF_MBEDTLS_SUCCESS; + } + } + + return HCF_MBEDTLS_FAILURE; +} + +HcfResult MbedtlsMdSpiCreate(const char *mbedtlsAlgoName, HcfMdSpi **spiObj) +{ + if (spiObj == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + MbedtlsMdSpiImpl *returnSpiImpl = (MbedtlsMdSpiImpl *)HcfMalloc(sizeof(MbedtlsMdSpiImpl), 0); + if (returnSpiImpl == NULL) { + LOGE("Failed to allocate returnImpl memory!"); + return HCF_ERR_MALLOC; + } + returnSpiImpl->ctx = MbedtlsEvpMdCtxNew(); + if (returnSpiImpl->ctx == NULL) { + LOGE("Failed to create ctx!"); + HcfFree(returnSpiImpl); + return HCF_ERR_MALLOC; + } + int32_t ret = MbedtlsEvpDigestInitEx(returnSpiImpl->ctx, mbedtlsAlgoName); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("Failed to init MD ret is %d!", ret); + MbedtlsEvpMdCtxFree(returnSpiImpl->ctx); + HcfFree(returnSpiImpl); + return HCF_ERR_CRYPTO_OPERATION; + } + returnSpiImpl->base.base.getClass = MbedtlsGetMdClass; + returnSpiImpl->base.base.destroy = MbedtlsDestroyMd; + returnSpiImpl->base.engineUpdateMd = MbedtlsEngineUpdateMd; + returnSpiImpl->base.engineDoFinalMd = MbedtlsEngineDoFinalMd; + returnSpiImpl->base.engineGetMdLength = MbedtlsEngineGetMdLength; + *spiObj = (HcfMdSpi *)returnSpiImpl; + + return HCF_SUCCESS; +} diff --git a/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h b/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h new file mode 100644 index 0000000..3ce3920 --- /dev/null +++ b/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef HCF_MBEDTLS_RAND_H +#define HCF_MBEDTLS_RAND_H + +#include "rand_spi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult MbedtlsRandSpiCreate(HcfRandSpi **spiObj); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c b/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c new file mode 100644 index 0000000..247eb69 --- /dev/null +++ b/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mbedtls_rand.h" + +#include "mbedtls/entropy.h" +#include "mbedtls/ctr_drbg.h" +#include "securec.h" +#include "log.h" +#include "memory.h" +#include "utils.h" + +typedef struct { + HcfRandSpi base; + mbedtls_entropy_context *entropy; + mbedtls_ctr_drbg_context *ctrDrbg; +} HcfRandSpiImpl; + +static const char *GetMbedtlsRandClass(void) +{ + return "RandMbedtls"; +} + +static mbedtls_entropy_context *MbedtlsGetMdEntropy(HcfRandSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + + return ((HcfRandSpiImpl *)self)->entropy; +} + +static mbedtls_ctr_drbg_context *MbedtlsGetMdCtrDrbg(HcfRandSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + return ((HcfRandSpiImpl *)self)->ctrDrbg; +} + +static HcfResult MbedtlsGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBlob *random) +{ + if ((self == NULL) || (random == NULL)) { + LOGE("Invalid params!"); + return HCF_INVALID_PARAMS; + } + if (numBytes <= 0) { + LOGE("Invalid numBytes!"); + return HCF_INVALID_PARAMS; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg(self); + if (ctrDrbg == NULL) { + LOGE("Invalid ctrDrbg null!"); + return HCF_INVALID_PARAMS; + } + random->data = (uint8_t *)HcfMalloc(numBytes, 0); + if (random->data == NULL) { + LOGE("Failed to allocate random->data memory!"); + return HCF_ERR_MALLOC; + } + int32_t ret = mbedtls_ctr_drbg_random(ctrDrbg, random->data, numBytes); + if (ret != 0) { + LOGE("RAND_bytes return is %d error!", ret); + HcfFree(random->data); + random->data = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } + random->len = numBytes; + + return HCF_SUCCESS; +} + +static const char *MbedtlsGetRandAlgoName(HcfRandSpi *self) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return NULL; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + + return MBEDTLS_RAND_ALGORITHM; +} + +static void MbedtlsSetSeed(HcfRandSpi *self, HcfBlob *seed) +{ + if ((self == NULL) || (seed == NULL)) { + LOGE("Invalid params!"); + return; + } + if ((seed->data == NULL) || (seed->len == 0)) { + LOGE("Invalid numBytes!"); + return; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg(self); + if (ctrDrbg == NULL) { + LOGE("Invalid ctrDrbg params!"); + return; + } + mbedtls_entropy_context *entropy = MbedtlsGetMdEntropy(self); + if (entropy == NULL) { + LOGE("Invalid entropy params!"); + return; + } + int32_t ret = mbedtls_ctr_drbg_seed(ctrDrbg, mbedtls_entropy_func, entropy, + (const unsigned char *)seed->data, seed->len); + if (ret != 0) { + LOGE("seed return is %d error!", ret); + return; + } +} + +static void DestroyMbedtlsRand(HcfObjectBase *self) +{ + if (self == NULL) { + LOGE("Self ptr is NULL!"); + return; + } + if (!HcfIsClassMatch(self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg((HcfRandSpi *)self); + if (ctrDrbg != NULL) { + mbedtls_ctr_drbg_free(ctrDrbg); + HcfFree(ctrDrbg); + } + mbedtls_entropy_context *entropy = MbedtlsGetMdEntropy((HcfRandSpi *)self); + if (entropy != NULL) { + mbedtls_entropy_free(entropy); + HcfFree(entropy); + } + HcfFree(self); +} + +static int32_t MbedtlsRandInitEx(mbedtls_entropy_context **entropy, mbedtls_ctr_drbg_context **ctrDrbg) +{ + if ((entropy == NULL) || (ctrDrbg == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + *entropy = (mbedtls_entropy_context *)HcfMalloc(sizeof(mbedtls_entropy_context), 0); + if (*entropy == NULL) { + LOGE("Failed to allocate *entropy memory!"); + return HCF_ERR_MALLOC; + } + *ctrDrbg = (mbedtls_ctr_drbg_context *)HcfMalloc(sizeof(mbedtls_ctr_drbg_context), 0); + if (*ctrDrbg == NULL) { + HcfFree(*entropy); + LOGE("Failed to allocate *ctrDrbg memory!"); + return HCF_ERR_MALLOC; + } + mbedtls_entropy_init(*entropy); + mbedtls_ctr_drbg_init(*ctrDrbg); + int32_t ret = mbedtls_ctr_drbg_seed(*ctrDrbg, mbedtls_entropy_func, *entropy, NULL, 0); + if (ret != 0) { + LOGE("Failed seed ret is %d!", ret); + mbedtls_entropy_free(*entropy); + mbedtls_ctr_drbg_free(*ctrDrbg); + HcfFree(*entropy); + HcfFree(*ctrDrbg); + return HCF_ERR_CRYPTO_OPERATION; + } + + return HCF_SUCCESS; +} + +HcfResult MbedtlsRandSpiCreate(HcfRandSpi **spiObj) +{ + if (spiObj == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + HcfRandSpiImpl *returnSpiImpl = (HcfRandSpiImpl *)HcfMalloc(sizeof(HcfRandSpiImpl), 0); + if (returnSpiImpl == NULL) { + LOGE("Failed to allocate *returnSpiImpl memory!"); + return HCF_ERR_MALLOC; + } + int32_t ret = MbedtlsRandInitEx(&(returnSpiImpl->entropy), &(returnSpiImpl->ctrDrbg)); + if (ret != HCF_SUCCESS) { + LOGE("Failed to allocate entropy ctrDrbg memory!"); + return HCF_ERR_MALLOC; + } + returnSpiImpl->base.base.getClass = GetMbedtlsRandClass; + returnSpiImpl->base.base.destroy = DestroyMbedtlsRand; + returnSpiImpl->base.engineGenerateRandom = MbedtlsGenerateRandom; + returnSpiImpl->base.engineSetSeed = MbedtlsSetSeed; + returnSpiImpl->base.engineGetAlgoName = MbedtlsGetRandAlgoName; + *spiObj = (HcfRandSpi *)returnSpiImpl; + + return HCF_SUCCESS; +} diff --git a/plugin/plugin.gni b/plugin/plugin.gni index 8a18e7f..2d7f0d1 100644 --- a/plugin/plugin.gni +++ b/plugin/plugin.gni @@ -96,3 +96,17 @@ plugin_files = plugin_asy_key_generator_files + plugin_key_agreement_files + plugin_sym_key_files + plugin_cipher_files + plugin_hmac_files + plugin_rand_files + plugin_md_files + plugin_signature_files + plugin_common_files + plugin_kdf_files + +mbedtls_plugin_inc_path = [ + "${base_path}/interfaces/innerkits/common", + "${plugin_path}/mbedtls_plugin/common", + "${plugin_path}/mbedtls_plugin/md/inc", + "${plugin_path}/mbedtls_plugin/rand/inc", + "//base/security/crypto_framework/frameworks/spi", + "//base/security/crypto_framework/common/inc", +] + +mbedtls_plugin_files = [ + "${plugin_path}/mbedtls_plugin/md/src/mbedtls_md.c", + "${plugin_path}/mbedtls_plugin/rand/src/mbedtls_rand.c", +] -- Gitee From bc2323ece7437ff727c52f891a5735ba8e4d2c28 Mon Sep 17 00:00:00 2001 From: lcc Date: Sat, 7 Sep 2024 11:27:08 +0800 Subject: [PATCH 25/32] =?UTF-8?q?=E9=80=82=E9=85=8Dmini=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=9E=B6=E6=9E=84=E5=9B=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- .../zh-cn_crypto_framework_architecture.png | Bin 36019 -> 27719 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/figures/zh-cn_crypto_framework_architecture.png b/figures/zh-cn_crypto_framework_architecture.png index a35cc52b27ea1b2dfd68eb762a1d0dd102bdd68d..7c73e2ebd609c95d76c3f075b31ff45062190de6 100755 GIT binary patch literal 27719 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

`&pa}RxB~fb93Cdvd8G; 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�i*I^##fG|#Hs@h>1`N& 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 z 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 jqtGYp;WwN&aKM=Z98<>kz{Cmnawi==Z+>N%7c? -- Gitee From 43d973048d0035bf117015c70f2446cd60cbc7f9 Mon Sep 17 00:00:00 2001 From: lcc Date: Wed, 11 Sep 2024 10:17:13 +0800 Subject: [PATCH 26/32] =?UTF-8?q?README=E6=96=87=E4=BB=B6=E9=80=82?= =?UTF-8?q?=E9=85=8Dmini=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- README_zh.md | 3 +++ common/inc/log.h | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/README_zh.md b/README_zh.md index 7cad669..37a292d 100644 --- a/README_zh.md +++ b/README_zh.md @@ -21,14 +21,17 @@ base/security/crypto_framwork ├── test # unitest ├── common # 内部依赖的公共方法 ├── plugin # 算法适配的插件实现 +│ ├── mbedtls_plugin # mbedtls 插件 │ └── openssl_plugin # openssl 插件 ├── frameworks # 框架实现层 │ ├── spi # SPI的接口 │ ├── js +│ ├── jsi # 通过jsi封装的JS接口代码实现 │ └── napi # 通过napi封装的JS接口代码实现 │ ├── algorithm_parameter # 算法参数 │ ├── crypto_operation # 算法操作，包括mac、md、加解密、签名验签、秘钥协商 │ ├── key # 秘钥材料 +│ ├── native # 对外提供算法库C接口 │ └── rand # 随机数 ``` diff --git a/common/inc/log.h b/common/inc/log.h index 563a38e..ded8621 100644 --- a/common/inc/log.h +++ b/common/inc/log.h @@ -19,7 +19,7 @@ #include #include -#ifdef MINI_HILOG_ENABLE +#if defined(MINI_HILOG_ENABLE) #include "hiview_log.h" @@ -28,7 +28,7 @@ #define LOGW(fmt, ...) HILOG_WARN(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) #define LOGE(fmt, ...) HILOG_ERROR(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) -#elif HILOG_ENABLE +#elif defined(HILOG_ENABLE) enum HcfLogLevel { HCF_LOG_LEVEL_I, -- Gitee From f12cadb20c95e387bc6dba013cb88f99ec7709ac Mon Sep 17 00:00:00 2001 From: lanming Date: Sat, 14 Sep 2024 11:42:54 +0800 Subject: [PATCH 27/32] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=86=85=E5=AD=98?= =?UTF-8?q?=E6=B3=84=E6=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lanming --- .../ecc_common_param_spec_generator_openssl.c | 42 ++++++++++--------- 1 file changed, 23 insertions(+), 19 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 aa460d8..97df1dd 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 @@ -301,25 +301,29 @@ static HcfResult InitEccPoint(const int32_t curveNameValue, EC_GROUP **ecGroup, *ecGroup = NULL; return HCF_ERR_CRYPTO_OPERATION; } - *x = OpensslBnNew(); - if (*x == NULL) { - LOGE("Failed to allocate memory for BIGNUM x."); - OpensslEcGroupFree(*ecGroup); - *ecGroup = NULL; - OpensslEcPointFree(*ecPoint); - *ecPoint = NULL; - return HCF_ERR_CRYPTO_OPERATION; + if (x != NULL) { + *x = OpensslBnNew(); + if (*x == NULL) { + LOGE("Failed to allocate memory for BIGNUM x."); + OpensslEcGroupFree(*ecGroup); + *ecGroup = NULL; + OpensslEcPointFree(*ecPoint); + *ecPoint = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } } - *y = OpensslBnNew(); - if (*y == NULL) { - LOGE("Failed to allocate memory for BIGNUM y."); - OpensslBnFree(*x); - *x = NULL; - OpensslEcGroupFree(*ecGroup); - *ecGroup = NULL; - OpensslEcPointFree(*ecPoint); - *ecPoint = NULL; - return HCF_ERR_CRYPTO_OPERATION; + if (y != NULL) { + *y = OpensslBnNew(); + if (*y == NULL) { + LOGE("Failed to allocate memory for BIGNUM y."); + OpensslBnFree(*x); + *x = NULL; + OpensslEcGroupFree(*ecGroup); + *ecGroup = NULL; + OpensslEcPointFree(*ecPoint); + *ecPoint = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } } return HCF_SUCCESS; } @@ -439,7 +443,7 @@ HcfResult HcfEngineGetEncodedPoint(const int32_t curveNameValue, HcfPoint *point BIGNUM *bnY = NULL; HcfResult ret = HCF_SUCCESS; do { - ret = InitEccPoint(curveNameValue, &ecGroup, &ecPoint, &bnX, &bnY); + ret = InitEccPoint(curveNameValue, &ecGroup, &ecPoint, NULL, NULL); if (ret != HCF_SUCCESS) { LOGE("Failed to get EccPoint."); break; -- Gitee From 00b265f935b1cfcb7aa3d4f47579c9c3fc73c0bb Mon Sep 17 00:00:00 2001 From: hhhFun Date: Sat, 14 Sep 2024 19:15:27 +0800 Subject: [PATCH 28/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=86=85=E5=AD=98?= =?UTF-8?q?=E6=B3=84=E6=BC=8F=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- plugin/openssl_plugin/common/src/openssl_common.c | 4 ++-- .../cipher/src/cipher_sm2_crypto_util_openssl.c | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index a80d789..512219e 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -432,9 +432,9 @@ HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest) } if (IsBigEndian()) { - *dest = OpensslBin2Bn((src->data), (src->len), NULL); + *dest = OpensslBin2Bn((src->data), (src->len), *dest); } else { - *dest = OpensslLeBin2Bn((src->data), (src->len), NULL); + *dest = OpensslLeBin2Bn((src->data), (src->len), *dest); } if (*dest == NULL) { diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_crypto_util_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_crypto_util_openssl.c index c3405fd..94d70a8 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_crypto_util_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_sm2_crypto_util_openssl.c @@ -33,8 +33,6 @@ static HcfResult BuildSm2Ciphertext(const Sm2CipherTextSpec *spec, struct Sm2Cip LOGE("Build y failed."); return HCF_ERR_CRYPTO_OPERATION; } - sm2Text->c3 = OpensslAsn1OctetStringNew(); - sm2Text->c2 = OpensslAsn1OctetStringNew(); if (sm2Text->c3 == NULL || sm2Text->c2 == NULL) { LOGE("SM2 openssl [ASN1_OCTET_STRING_new] c3 c2 fail"); HcfPrintOpensslError(); -- Gitee From c0778137c47f1ff6d4f6521525e374f0fc720302 Mon Sep 17 00:00:00 2001 From: lcc Date: Mon, 23 Sep 2024 15:51:44 +0800 Subject: [PATCH 29/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9codecheck=20=E5=91=8A?= =?UTF-8?q?=E8=AD=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- frameworks/js/jsi/src/jsi_list.cpp | 6 +++--- frameworks/js/jsi/src/jsi_md.cpp | 17 +++++++---------- frameworks/js/jsi/src/jsi_rand.cpp | 26 +++++++++++++------------- frameworks/js/jsi/src/jsi_utils.cpp | 5 ++--- 4 files changed, 25 insertions(+), 29 deletions(-) diff --git a/frameworks/js/jsi/src/jsi_list.cpp b/frameworks/js/jsi/src/jsi_list.cpp index 14343b0..eb3b1e1 100644 --- a/frameworks/js/jsi/src/jsi_list.cpp +++ b/frameworks/js/jsi/src/jsi_list.cpp @@ -45,7 +45,7 @@ void ListObjInit(LiteAlgType type) HcfResult ListAddObjNode(LiteAlgType type, uint32_t addAddr) { - ObjList *obj = (ObjList *)HcfMalloc(sizeof(ObjList), 0); + ObjList *obj = static_cast(HcfMalloc(sizeof(ObjList), 0)); if (obj == nullptr) { return HCF_ERR_MALLOC; } @@ -69,7 +69,7 @@ void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr) } if ((obj->objAddr != 0) && (obj->objAddr == deleteAddr)) { LOS_ListDelete(&(obj->listNode)); - HcfObjDestroy((void *)deleteAddr); + HcfObjDestroy(static_cast(deleteAddr)); obj->objAddr = 0; HcfFree(obj); obj = nullptr; @@ -87,7 +87,7 @@ void ListDestroy(LiteAlgType type) return; } LOS_ListDelete(&(obj->listNode)); - HcfObjDestroy((void *)(obj->objAddr)); + HcfObjDestroy(static_cast(obj->objAddr)); HcfFree(obj); obj = nullptr; } diff --git a/frameworks/js/jsi/src/jsi_md.cpp b/frameworks/js/jsi/src/jsi_md.cpp index 0d0d361..226f447 100644 --- a/frameworks/js/jsi/src/jsi_md.cpp +++ b/frameworks/js/jsi/src/jsi_md.cpp @@ -45,7 +45,7 @@ JSIValue CryptoFrameworkLiteModule::CreateMd(const JSIValue thisVal, const JSIVa res = ListAddObjNode(JSI_ALG_MD, (uint32_t)mdObj); if (res != HCF_SUCCESS) { LOGE("md add node is %d err!", res); - HcfObjDestroy((void *)mdObj); + HcfObjDestroy(static_cast(mdObj)); return ThrowErrorCodeResult(res); } @@ -70,10 +70,9 @@ JSIValue CryptoFrameworkLiteModule::Update(const JSIValue thisVal, const JSIValu { if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE)) { LOGE("Update args is null!"); - CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); return JSI::CreateUndefined(); } - HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("Update mdObj is null!!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); @@ -107,7 +106,7 @@ JSIValue CryptoFrameworkLiteModule::UpdateSync(const JSIValue thisVal, const JSI LOGE("UpdateSync args is null!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); } - HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("UpdateSync mdObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); @@ -117,8 +116,7 @@ JSIValue CryptoFrameworkLiteModule::UpdateSync(const JSIValue thisVal, const JSI HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &inBlob); if (errCode != HCF_SUCCESS) { LOGE("UpdateSync inBlob is null!"); - CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); - return JSI::CreateUndefined(); + return ThrowErrorCodeResult(errCode); } errCode = mdObj->update(mdObj, &inBlob); @@ -134,10 +132,9 @@ JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValu { if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { LOGE("Digest args is err or mdObj nullptr!"); - CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); return JSI::CreateUndefined(); } - HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("Digest mdObj is null!!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); @@ -160,7 +157,7 @@ JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValu JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("DigestSync mdObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); @@ -182,7 +179,7 @@ JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSI JSIValue CryptoFrameworkLiteModule::GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("GetMdLength mdObj is null!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); diff --git a/frameworks/js/jsi/src/jsi_rand.cpp b/frameworks/js/jsi/src/jsi_rand.cpp index c1059e0..8e6d82c 100644 --- a/frameworks/js/jsi/src/jsi_rand.cpp +++ b/frameworks/js/jsi/src/jsi_rand.cpp @@ -38,7 +38,7 @@ JSIValue CryptoFrameworkLiteModule::CreateRandom(const JSIValue thisVal, const J res = ListAddObjNode(JSI_ALG_RAND, (uint32_t)randObj); if (res != HCF_SUCCESS) { LOGE("rand add node is %d err!", res); - HcfObjDestroy((void *)randObj); + HcfObjDestroy(static_cast(randObj)); return ThrowErrorCodeResult(res); } @@ -58,14 +58,14 @@ JSIValue CryptoFrameworkLiteModule::CreateRandom(const JSIValue thisVal, const J JSIValue CryptoFrameworkLiteModule::GenerateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); - if (randObj == nullptr) { - LOGE("GenerateRandom randObj is null!"); - CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); - return JSI::CreateUndefined(); - } if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE) || (args[ARRAY_INDEX_ONE] == nullptr)) { LOGE("GenerateRandom params is err!"); + return JSI::CreateUndefined(); + } + + HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); return JSI::CreateUndefined(); } @@ -93,14 +93,14 @@ JSIValue CryptoFrameworkLiteModule::GenerateRandom(const JSIValue thisVal, const JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); - if (randObj == nullptr) { - LOGE("GenerateRandom randObj is null!!"); + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("GenerateRandomSync params is err"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); } - if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { - LOGE("GenerateRandomSync params is err"); + HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); } @@ -124,7 +124,7 @@ JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, c JSIValue CryptoFrameworkLiteModule::SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); if (randObj == nullptr) { LOGE("SetSeed randObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); diff --git a/frameworks/js/jsi/src/jsi_utils.cpp b/frameworks/js/jsi/src/jsi_utils.cpp index 0cbbb46..e10d29e 100644 --- a/frameworks/js/jsi/src/jsi_utils.cpp +++ b/frameworks/js/jsi/src/jsi_utils.cpp @@ -34,10 +34,9 @@ HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob) size_t arraySize = 0; size_t byteOffset = 0; JSIValue arrayBuffer = nullptr; - uint8_t *dataArray; HcfResult ret = HCF_SUCCESS; do { - dataArray = JSI::GetTypedArrayInfo(value, arrayType, arraySize, arrayBuffer, byteOffset); + uint8_t *dataArray = JSI::GetTypedArrayInfo(value, arrayType, arraySize, arrayBuffer, byteOffset); if (dataArray == nullptr) { ret = HCF_ERR_CRYPTO_OPERATION; break; @@ -47,7 +46,7 @@ HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob) ret = HCF_INVALID_PARAMS; break; } - blob->data = (uint8_t *)HcfMalloc(arraySize, 0); + blob->data = static_cast(HcfMalloc(arraySize, 0)); if (blob->data == nullptr) { ret = HCF_ERR_MALLOC; break; -- Gitee From 053eb9ec9f05f666fff81a3abc44a0c6f15c5e1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=90=8C=E8=90=8C=E8=90=8C=E6=96=B0?= Date: Mon, 23 Sep 2024 09:22:18 +0800 Subject: [PATCH 30/32] =?UTF-8?q?=E5=BC=80=E6=94=BE=E5=A4=B4=E6=96=87?= =?UTF-8?q?=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 萌萌萌新 --- bundle.json | 28 + frameworks/cj/include/cipher_impl.h | 90 +- frameworks/cj/include/crypto_ffi.h | 388 +- frameworks/cj/include/key_impl.h | 81 +- frameworks/cj/include/mac_impl.h | 86 +- frameworks/cj/include/md_impl.h | 82 +- frameworks/cj/include/random_impl.h | 82 +- frameworks/cj/include/sign_impl.h | 92 +- .../cj/include/sym_key_generator_impl.h | 82 +- frameworks/cj/include/sym_key_impl.h | 74 +- frameworks/cj/src/cipher_impl.cpp | 196 +- frameworks/cj/src/crypto_ffi.cpp | 3632 ++++++++--------- frameworks/cj/src/crypto_mock.cpp | 104 +- frameworks/cj/src/key_impl.cpp | 127 +- frameworks/cj/src/mac_impl.cpp | 140 +- frameworks/cj/src/md_impl.cpp | 120 +- frameworks/cj/src/random_impl.cpp | 140 +- frameworks/cj/src/sign_impl.cpp | 170 +- frameworks/cj/src/sym_key_impl.cpp | 78 +- 19 files changed, 2910 insertions(+), 2882 deletions(-) diff --git a/bundle.json b/bundle.json index e0f37ed..e64ffc4 100644 --- a/bundle.json +++ b/bundle.json @@ -90,6 +90,34 @@ ], "header_base": "//base/security/crypto_framework/interfaces/innerkits" } + }, + { + "name": "//base/security/crypto_framework/frameworks/cj:cj_cryptoframework_ffi", + "header": { + "header_files": [ + "asy_key_generator_impl.h", + "asy_key_spec_generator_impl.h", + "cipher_impl.h", + "crypto_ffi.h", + "dh_key_util_impl.h", + "ecc_key_util_impl.h", + "kdf_impl.h", + "key_agreement_impl.h", + "key_impl.h", + "key_pair_impl.h", + "mac_impl.h", + "md_impl.h", + "pri_key_impl.h", + "pub_key_impl.h", + "random_impl.h", + "sign_impl.h", + "sm2_crypto_util_impl.h", + "sym_key_generator_impl.h", + "sym_key_impl.h", + "verify_impl.h" + ], + "header_base": "//base/security/crypto_framework/frameworks/cj/include" + } } ], "test": [ diff --git a/frameworks/cj/include/cipher_impl.h b/frameworks/cj/include/cipher_impl.h index 410b1cf..28b0033 100644 --- a/frameworks/cj/include/cipher_impl.h +++ b/frameworks/cj/include/cipher_impl.h @@ -1,45 +1,45 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef CIPHER_IMPL_H -#define CIPHER_IMPL_H - -#include "ffi_remote_data.h" -#include "algorithm_parameter.h" -#include "key.h" -#include "cipher.h" -#include "blob.h" - -namespace OHOS { -namespace CryptoFramework { -class CipherImpl : public OHOS::FFI::FFIData { - DECL_TYPE(CipherImpl, OHOS::FFI::FFIData) -public: - explicit CipherImpl(HcfCipher *cipher); - ~CipherImpl(); - HcfResult CipherInit(HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params); - HcfResult CipherUpdate(HcfBlob *input, HcfBlob *output); - HcfResult CipherDoFinal(HcfBlob *input, HcfBlob *output); - HcfResult SetCipherSpec(CipherSpecItem item, HcfBlob pSource); - HcfResult GetCipherSpecString(CipherSpecItem item, char *returnString); - HcfResult GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array); - const char *GetAlgorithm(int32_t* errCode); - -private: - HcfCipher *cipher_; -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CIPHER_IMPL_H +#define CIPHER_IMPL_H + +#include "ffi_remote_data.h" +#include "algorithm_parameter.h" +#include "key.h" +#include "cipher.h" +#include "blob.h" + +namespace OHOS { +namespace CryptoFramework { +class CipherImpl : public OHOS::FFI::FFIData { + DECL_TYPE(CipherImpl, OHOS::FFI::FFIData) +public: + explicit CipherImpl(HcfCipher *cipher); + ~CipherImpl(); + HcfResult CipherInit(HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params); + HcfResult CipherUpdate(HcfBlob *input, HcfBlob *output); + HcfResult CipherDoFinal(HcfBlob *input, HcfBlob *output); + HcfResult SetCipherSpec(CipherSpecItem item, HcfBlob pSource); + HcfResult GetCipherSpecString(CipherSpecItem item, char *returnString); + HcfResult GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array); + const char *GetAlgorithm(int32_t* errCode); + +private: + HcfCipher *cipher_; +}; +} +} + +#endif diff --git a/frameworks/cj/include/crypto_ffi.h b/frameworks/cj/include/crypto_ffi.h index b885088..8f6254b 100644 --- a/frameworks/cj/include/crypto_ffi.h +++ b/frameworks/cj/include/crypto_ffi.h @@ -1,194 +1,194 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef CRYPTO_FFI_H -#define CRYPTO_FFI_H - -#include "asy_key_generator_impl.h" -#include "asy_key_spec_generator_impl.h" -#include "cipher_impl.h" -#include "dh_key_util_impl.h" -#include "detailed_iv_params.h" -#include "detailed_gcm_params.h" -#include "detailed_ccm_params.h" -#include "detailed_dsa_key_params.h" -#include "detailed_ecc_key_params.h" -#include "detailed_rsa_key_params.h" -#include "detailed_alg_25519_key_params.h" -#include "detailed_dh_key_params.h" -#include "ecc_key_util_impl.h" -#include "kdf_impl.h" -#include "key_agreement_impl.h" -#include "key_pair_impl.h" -#include "mac_impl.h" -#include "md_impl.h" -#include "pri_key_impl.h" -#include "pub_key_impl.h" -#include "random_impl.h" -#include "securec.h" -#include "sign_impl.h" -#include "sm2_crypto_util_impl.h" -#include "sym_key_generator_impl.h" -#include "sym_key_impl.h" -#include "verify_impl.h" - -extern "C" { - typedef struct { - HcfBlob iv; - HcfBlob add; - HcfBlob authTag; - } CParamsSpec; - - // random - FFI_EXPORT int64_t FfiOHOSCreateRandom(int32_t* errCode); - FFI_EXPORT const char *FfiOHOSRandomGetAlgName(int64_t id, int32_t* errCode); - FFI_EXPORT HcfBlob FfiOHOSGenerateRandom(int64_t id, int32_t numBytes, int32_t* errCode); - FFI_EXPORT void FfiOHOSSetSeed(int64_t id, HcfBlob *seed, int32_t* errCode); - - // md - FFI_EXPORT int64_t FfiOHOSCreateMd(char* algName, int32_t* errCode); - FFI_EXPORT int32_t FfiOHOSMdUpdate(int64_t id, HcfBlob *input); - FFI_EXPORT HcfBlob FfiOHOSDigest(int64_t id, int32_t* errCode); - FFI_EXPORT uint32_t FfiOHOSGetMdLength(int64_t id, int32_t* errCode); - - // symkeygenerator - FFI_EXPORT int64_t FfiOHOSCreateSymKeyGenerator(char* algName, int32_t* errCode); - FFI_EXPORT const char *FfiOHOSSymKeyGeneratorGetAlgName(int64_t id, int32_t* errCode); - FFI_EXPORT int64_t FfiOHOSGenerateSymKey(int64_t id, int32_t* errCode); - FFI_EXPORT int64_t FfiOHOSConvertKey(int64_t id, HcfBlob *key, int32_t* errCode); - - // symkey - FFI_EXPORT const char *FfiOHOSSymKeyGetAlgName(int64_t id, int32_t* errCode); - FFI_EXPORT const char *FfiOHOSSymKeyGetFormat(int64_t id, int32_t* errCode); - FFI_EXPORT int32_t FfiOHOSSymKeyGetEncoded(int64_t id, HcfBlob *returnBlob); - FFI_EXPORT void FfiOHOSClearMem(int64_t id); - FFI_EXPORT void* FfiOHOSSymKeyGetHcfKey(int64_t id); - - // cipher - FFI_EXPORT int64_t FfiOHOSCreateCipher(char* transformation, int32_t* errCode); - FFI_EXPORT int32_t FfiOHOSCipherInitByIv(int64_t id, int32_t opMode, void* key, HcfBlob blob1); - FFI_EXPORT int32_t FfiOHOSCipherInitByGcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec); - FFI_EXPORT int32_t FfiOHOSCipherInitByCcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec); - FFI_EXPORT int32_t FfiOHOSCipherInitWithOutParams(int64_t id, int32_t opMode, void* key); - FFI_EXPORT int32_t FfiOHOSCipherUpdate(int64_t id, HcfBlob *input, HcfBlob *output); - FFI_EXPORT int32_t FfiOHOSCipherDoFinal(int64_t id, HcfBlob *input, HcfBlob *output); - FFI_EXPORT int32_t FfiOHOSSetCipherSpec(int64_t id, int32_t item, HcfBlob pSource); - FFI_EXPORT int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString); - FFI_EXPORT int32_t FfiOHOSGetCipherSpecUint8Array(int64_t id, int32_t item, HcfBlob *returnUint8Array); - FFI_EXPORT const char *FfiOHOSCipherGetAlgName(int64_t id, int32_t* errCode); - - // mac - FFI_EXPORT int64_t FFiOHOSCryptoMacConstructor(char* algName, int32_t* errCode); - FFI_EXPORT int32_t FfiOHOSCryptoMacInit(int64_t id, int64_t symKeyId); - FFI_EXPORT int32_t FfiOHOSCryptoMacUpdate(int64_t id, HcfBlob *input); - FFI_EXPORT HcfBlob FfiOHOSCryptoMacDoFinal(int64_t id, int32_t* errCode); - FFI_EXPORT uint32_t FfiOHOSCryptoGetMacLength(int64_t id); - - // sign - FFI_EXPORT int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode); - FFI_EXPORT int32_t FFiOHOSSignInit(int64_t sid, int64_t pid); - FFI_EXPORT int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input); - FFI_EXPORT int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output); - FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue); - FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue); - FFI_EXPORT int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue); - FFI_EXPORT int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); - - // verify - FFI_EXPORT int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode); - FFI_EXPORT int32_t FFiOHOSVerifyInit(int64_t vid, int64_t pid); - FFI_EXPORT int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input); - FFI_EXPORT bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode); - FFI_EXPORT int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output); - FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue); - FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue); - FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue); - FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); - - // asykeygenerator - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode); - - // asykeyspecgenerator - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec( - HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode); - - // prikey - FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode); - FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); - FFI_EXPORT char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); - FFI_EXPORT int32_t FFiOHOSPriKeyClearMem(int64_t id); - FFI_EXPORT int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT const char *FfiOHOSPriKeyKeyGetFormat(int64_t id, int32_t* errCode); - - // pubkey - FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode); - FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); - FFI_EXPORT char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); - FFI_EXPORT int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); - FFI_EXPORT const char *FfiOHOSPubKeyKeyGetFormat(int64_t id, int32_t* errCode); - - // keypair - FFI_EXPORT int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode); - FFI_EXPORT int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode); - - // kdf - FFI_EXPORT int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode); - FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params); - FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params); - - // ecc_key_util - FFI_EXPORT HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode); - FFI_EXPORT HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode); - FFI_EXPORT HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint( - char *curveName, HcfPoint point, char *format, int32_t *errCode); - - // keyagreement - FFI_EXPORT int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode); - FFI_EXPORT HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode); - - // dh_key_util - FFI_EXPORT HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec( - int32_t pLen, int32_t skLen, int32_t *errCode); - - // sm2_crypto_util - FFI_EXPORT HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode); - FFI_EXPORT Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode); -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CRYPTO_FFI_H +#define CRYPTO_FFI_H + +#include "asy_key_generator_impl.h" +#include "asy_key_spec_generator_impl.h" +#include "cipher_impl.h" +#include "dh_key_util_impl.h" +#include "detailed_iv_params.h" +#include "detailed_gcm_params.h" +#include "detailed_ccm_params.h" +#include "detailed_dsa_key_params.h" +#include "detailed_ecc_key_params.h" +#include "detailed_rsa_key_params.h" +#include "detailed_alg_25519_key_params.h" +#include "detailed_dh_key_params.h" +#include "ecc_key_util_impl.h" +#include "kdf_impl.h" +#include "key_agreement_impl.h" +#include "key_pair_impl.h" +#include "mac_impl.h" +#include "md_impl.h" +#include "pri_key_impl.h" +#include "pub_key_impl.h" +#include "random_impl.h" +#include "securec.h" +#include "sign_impl.h" +#include "sm2_crypto_util_impl.h" +#include "sym_key_generator_impl.h" +#include "sym_key_impl.h" +#include "verify_impl.h" + +extern "C" { + typedef struct { + HcfBlob iv; + HcfBlob add; + HcfBlob authTag; + } CParamsSpec; + + // random + FFI_EXPORT int64_t FfiOHOSCreateRandom(int32_t* errCode); + FFI_EXPORT const char *FfiOHOSRandomGetAlgName(int64_t id, int32_t* errCode); + FFI_EXPORT HcfBlob FfiOHOSGenerateRandom(int64_t id, int32_t numBytes, int32_t* errCode); + FFI_EXPORT void FfiOHOSSetSeed(int64_t id, HcfBlob *seed, int32_t* errCode); + + // md + FFI_EXPORT int64_t FfiOHOSCreateMd(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FfiOHOSMdUpdate(int64_t id, HcfBlob *input); + FFI_EXPORT HcfBlob FfiOHOSDigest(int64_t id, int32_t* errCode); + FFI_EXPORT uint32_t FfiOHOSGetMdLength(int64_t id, int32_t* errCode); + + // symkeygenerator + FFI_EXPORT int64_t FfiOHOSCreateSymKeyGenerator(char* algName, int32_t* errCode); + FFI_EXPORT const char *FfiOHOSSymKeyGeneratorGetAlgName(int64_t id, int32_t* errCode); + FFI_EXPORT int64_t FfiOHOSGenerateSymKey(int64_t id, int32_t* errCode); + FFI_EXPORT int64_t FfiOHOSConvertKey(int64_t id, HcfBlob *key, int32_t* errCode); + + // symkey + FFI_EXPORT const char *FfiOHOSSymKeyGetAlgName(int64_t id, int32_t* errCode); + FFI_EXPORT const char *FfiOHOSSymKeyGetFormat(int64_t id, int32_t* errCode); + FFI_EXPORT int32_t FfiOHOSSymKeyGetEncoded(int64_t id, HcfBlob *returnBlob); + FFI_EXPORT void FfiOHOSClearMem(int64_t id); + FFI_EXPORT void* FfiOHOSSymKeyGetHcfKey(int64_t id); + + // cipher + FFI_EXPORT int64_t FfiOHOSCreateCipher(char* transformation, int32_t* errCode); + FFI_EXPORT int32_t FfiOHOSCipherInitByIv(int64_t id, int32_t opMode, void* key, HcfBlob blob1); + FFI_EXPORT int32_t FfiOHOSCipherInitByGcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec); + FFI_EXPORT int32_t FfiOHOSCipherInitByCcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec); + FFI_EXPORT int32_t FfiOHOSCipherInitWithOutParams(int64_t id, int32_t opMode, void* key); + FFI_EXPORT int32_t FfiOHOSCipherUpdate(int64_t id, HcfBlob *input, HcfBlob *output); + FFI_EXPORT int32_t FfiOHOSCipherDoFinal(int64_t id, HcfBlob *input, HcfBlob *output); + FFI_EXPORT int32_t FfiOHOSSetCipherSpec(int64_t id, int32_t item, HcfBlob pSource); + FFI_EXPORT int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString); + FFI_EXPORT int32_t FfiOHOSGetCipherSpecUint8Array(int64_t id, int32_t item, HcfBlob *returnUint8Array); + FFI_EXPORT const char *FfiOHOSCipherGetAlgName(int64_t id, int32_t* errCode); + + // mac + FFI_EXPORT int64_t FFiOHOSCryptoMacConstructor(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FfiOHOSCryptoMacInit(int64_t id, int64_t symKeyId); + FFI_EXPORT int32_t FfiOHOSCryptoMacUpdate(int64_t id, HcfBlob *input); + FFI_EXPORT HcfBlob FfiOHOSCryptoMacDoFinal(int64_t id, int32_t* errCode); + FFI_EXPORT uint32_t FfiOHOSCryptoGetMacLength(int64_t id); + + // sign + FFI_EXPORT int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSSignInit(int64_t sid, int64_t pid); + FFI_EXPORT int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input); + FFI_EXPORT int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output); + FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue); + FFI_EXPORT int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue); + FFI_EXPORT int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue); + FFI_EXPORT int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); + + // verify + FFI_EXPORT int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSVerifyInit(int64_t vid, int64_t pid); + FFI_EXPORT int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input); + FFI_EXPORT bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode); + FFI_EXPORT int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output); + FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue); + FFI_EXPORT int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue); + FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue); + FFI_EXPORT int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue); + + // asykeygenerator + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode); + + // asykeyspecgenerator + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec( + HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode); + + // prikey + FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT int32_t FFiOHOSPriKeyClearMem(int64_t id); + FFI_EXPORT int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT const char *FfiOHOSPriKeyKeyGetFormat(int64_t id, int32_t* errCode); + + // pubkey + FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode); + FFI_EXPORT int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode); + FFI_EXPORT const char *FfiOHOSPubKeyKeyGetFormat(int64_t id, int32_t* errCode); + + // keypair + FFI_EXPORT int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode); + FFI_EXPORT int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode); + + // kdf + FFI_EXPORT int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode); + FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params); + FFI_EXPORT int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params); + + // ecc_key_util + FFI_EXPORT HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode); + FFI_EXPORT HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint( + char *curveName, HcfPoint point, char *format, int32_t *errCode); + + // keyagreement + FFI_EXPORT int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode); + FFI_EXPORT HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode); + + // dh_key_util + FFI_EXPORT HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec( + int32_t pLen, int32_t skLen, int32_t *errCode); + + // sm2_crypto_util + FFI_EXPORT HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode); + FFI_EXPORT Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode); +} + +#endif diff --git a/frameworks/cj/include/key_impl.h b/frameworks/cj/include/key_impl.h index 050f72f..dc16865 100644 --- a/frameworks/cj/include/key_impl.h +++ b/frameworks/cj/include/key_impl.h @@ -1,41 +1,40 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef KEY_IMPL_H -#define KEY_IMPL_H - -#include "ffi_remote_data.h" -#include "result.h" -#include "key.h" -#include "log.h" - -namespace OHOS { -namespace CryptoFramework { -class KeyImpl : public OHOS::FFI::FFIData { - DECL_TYPE(KeyImpl, OHOS::FFI::FFIData) -public: - explicit KeyImpl(HcfKey *hcfKey); - virtual ~KeyImpl(); - HcfKey *GetHcfKey() const; - const char *GetFormat(int32_t* errCode); - const char *GetAlgorithm(int32_t* errCode); - HcfResult GetEncoded(HcfBlob *returnBlob); - -protected: - HcfKey *hcfKey_; -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef KEY_IMPL_H +#define KEY_IMPL_H + +#include "ffi_remote_data.h" +#include "result.h" +#include "key.h" + +namespace OHOS { +namespace CryptoFramework { +class KeyImpl : public OHOS::FFI::FFIData { + DECL_TYPE(KeyImpl, OHOS::FFI::FFIData) +public: + explicit KeyImpl(HcfKey *hcfKey); + virtual ~KeyImpl(); + HcfKey *GetHcfKey() const; + const char *GetFormat(int32_t* errCode); + const char *GetAlgorithm(int32_t* errCode); + HcfResult GetEncoded(HcfBlob *returnBlob); + +protected: + HcfKey *hcfKey_; +}; +} +} + +#endif diff --git a/frameworks/cj/include/mac_impl.h b/frameworks/cj/include/mac_impl.h index dc04731..80a4b94 100644 --- a/frameworks/cj/include/mac_impl.h +++ b/frameworks/cj/include/mac_impl.h @@ -1,43 +1,43 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef MAC_IMPL_H -#define MAC_IMPL_H - -#include "ffi_remote_data.h" -#include "mac.h" -#include "blob.h" -#include "log.h" -#include "result.h" - -namespace OHOS { -namespace CryptoFramework { -class MacImpl : public OHOS::FFI::FFIData { - DECL_TYPE(MacImpl, OHOS::FFI::FFIData) -public: - explicit MacImpl(HcfMac *macObj); - ~MacImpl(); - HcfResult MacInit(HcfSymKey *symKey); - HcfResult MacUpdate(HcfBlob *input); - HcfResult MacDoFinal(HcfBlob *output); - uint32_t GetMacLength(); - -private: - HcfMac *macObj_ = nullptr; -}; -} -} - -#endif // MAC_IMPL_H +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MAC_IMPL_H +#define MAC_IMPL_H + +#include "ffi_remote_data.h" +#include "mac.h" +#include "blob.h" +#include "log.h" +#include "result.h" + +namespace OHOS { +namespace CryptoFramework { +class MacImpl : public OHOS::FFI::FFIData { + DECL_TYPE(MacImpl, OHOS::FFI::FFIData) +public: + explicit MacImpl(HcfMac *macObj); + ~MacImpl(); + HcfResult MacInit(HcfSymKey *symKey); + HcfResult MacUpdate(HcfBlob *input); + HcfResult MacDoFinal(HcfBlob *output); + uint32_t GetMacLength(); + +private: + HcfMac *macObj_ = nullptr; +}; +} +} + +#endif // MAC_IMPL_H diff --git a/frameworks/cj/include/md_impl.h b/frameworks/cj/include/md_impl.h index 869d897..b5ea593 100644 --- a/frameworks/cj/include/md_impl.h +++ b/frameworks/cj/include/md_impl.h @@ -1,41 +1,41 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MD_IMPL_H -#define MD_IMPL_H - -#include "ffi_remote_data.h" -#include "md.h" -#include "blob.h" -#include "log.h" -#include "result.h" - -namespace OHOS { -namespace CryptoFramework { -class MdImpl : public OHOS::FFI::FFIData { - DECL_TYPE(MdImpl, OHOS::FFI::FFIData) -public: - explicit MdImpl(HcfMd *mdObj); - ~MdImpl(); - HcfResult MdUpdate(HcfBlob *input); - HcfResult MdDoFinal(HcfBlob *output); - uint32_t GetMdLength(int32_t* errCode); - -private: - HcfMd *mdObj_ = nullptr; -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MD_IMPL_H +#define MD_IMPL_H + +#include "ffi_remote_data.h" +#include "md.h" +#include "blob.h" +#include "log.h" +#include "result.h" + +namespace OHOS { +namespace CryptoFramework { +class MdImpl : public OHOS::FFI::FFIData { + DECL_TYPE(MdImpl, OHOS::FFI::FFIData) +public: + explicit MdImpl(HcfMd *mdObj); + ~MdImpl(); + HcfResult MdUpdate(HcfBlob *input); + HcfResult MdDoFinal(HcfBlob *output); + uint32_t GetMdLength(int32_t* errCode); + +private: + HcfMd *mdObj_ = nullptr; +}; +} +} + +#endif diff --git a/frameworks/cj/include/random_impl.h b/frameworks/cj/include/random_impl.h index ff18d61..54c7ac2 100644 --- a/frameworks/cj/include/random_impl.h +++ b/frameworks/cj/include/random_impl.h @@ -1,41 +1,41 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef RANDOM_IMPL_H -#define RANDOM_IMPL_H - -#include "ffi_remote_data.h" -#include "rand.h" -#include "blob.h" -#include "result.h" -#include "log.h" - -namespace OHOS { -namespace CryptoFramework { -class RandomImpl : public OHOS::FFI::FFIData { - DECL_TYPE(RandomImpl, OHOS::FFI::FFIData) -public: - explicit RandomImpl(HcfRand *randObj); - ~RandomImpl(); - const char *GetAlgName(int32_t* errCode); - HcfBlob GenerateRandom(int32_t numBytes, int32_t* errCode); - void SetSeed(HcfBlob *seed, int32_t* errCode); - -private: - HcfRand *randObj_ = nullptr; -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef RANDOM_IMPL_H +#define RANDOM_IMPL_H + +#include "ffi_remote_data.h" +#include "rand.h" +#include "blob.h" +#include "result.h" +#include "log.h" + +namespace OHOS { +namespace CryptoFramework { +class RandomImpl : public OHOS::FFI::FFIData { + DECL_TYPE(RandomImpl, OHOS::FFI::FFIData) +public: + explicit RandomImpl(HcfRand *randObj); + ~RandomImpl(); + const char *GetAlgName(int32_t* errCode); + HcfBlob GenerateRandom(int32_t numBytes, int32_t* errCode); + void SetSeed(HcfBlob *seed, int32_t* errCode); + +private: + HcfRand *randObj_ = nullptr; +}; +} +} + +#endif diff --git a/frameworks/cj/include/sign_impl.h b/frameworks/cj/include/sign_impl.h index a93baf9..33d9219 100644 --- a/frameworks/cj/include/sign_impl.h +++ b/frameworks/cj/include/sign_impl.h @@ -1,46 +1,46 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef SIGN_IMPL_H -#define SIGN_IMPL_H - -#include "ffi_remote_data.h" -#include "signature.h" -#include "blob.h" -#include "result.h" -#include "pri_key.h" - -namespace OHOS { -namespace CryptoFramework { -class SignImpl : public OHOS::FFI::FFIData { - DECL_TYPE(SignImpl, OHOS::FFI::FFIData) -public: - explicit SignImpl(HcfSign *signObj); - ~SignImpl(); - HcfResult Init(HcfPriKey *priKey); - HcfResult Update(HcfBlob *input); - HcfResult Sign(HcfBlob *input, HcfBlob *output); - HcfResult SetSignSpecByNum(int32_t itemValue); - HcfResult SetSignSpecByArr(HcfBlob itemValue); - HcfResult GetSignSpecString(SignSpecItem item, char *itemValue); - HcfResult GetSignSpecNum(SignSpecItem item, int32_t *itemValue); - -private: - HcfSign *signObj_ = nullptr; -}; -} -} - -#endif // SIGN_IMPL_H +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SIGN_IMPL_H +#define SIGN_IMPL_H + +#include "ffi_remote_data.h" +#include "signature.h" +#include "blob.h" +#include "result.h" +#include "pri_key.h" + +namespace OHOS { +namespace CryptoFramework { +class SignImpl : public OHOS::FFI::FFIData { + DECL_TYPE(SignImpl, OHOS::FFI::FFIData) +public: + explicit SignImpl(HcfSign *signObj); + ~SignImpl(); + HcfResult Init(HcfPriKey *priKey); + HcfResult Update(HcfBlob *input); + HcfResult Sign(HcfBlob *input, HcfBlob *output); + HcfResult SetSignSpecByNum(int32_t itemValue); + HcfResult SetSignSpecByArr(HcfBlob itemValue); + HcfResult GetSignSpecString(SignSpecItem item, char *itemValue); + HcfResult GetSignSpecNum(SignSpecItem item, int32_t *itemValue); + +private: + HcfSign *signObj_ = nullptr; +}; +} +} + +#endif // SIGN_IMPL_H diff --git a/frameworks/cj/include/sym_key_generator_impl.h b/frameworks/cj/include/sym_key_generator_impl.h index ccbeeb1..9225480 100644 --- a/frameworks/cj/include/sym_key_generator_impl.h +++ b/frameworks/cj/include/sym_key_generator_impl.h @@ -1,41 +1,41 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef SYM_KEY_GENERATOR_IMPL_H -#define SYM_KEY_GENERATOR_IMPL_H - -#include "ffi_remote_data.h" -#include "sym_key.h" -#include "result.h" -#include "sym_key_generator.h" -#include "log.h" - -namespace OHOS { -namespace CryptoFramework { -class SymKeyGeneratorImpl : public OHOS::FFI::FFIData { - DECL_TYPE(SymKeyGeneratorImpl, OHOS::FFI::FFIData) -public: - explicit SymKeyGeneratorImpl(HcfSymKeyGenerator *generator); - ~SymKeyGeneratorImpl(); - const char *GetAlgName(int32_t* errCode); - HcfResult GenerateSymKey(HcfSymKey **symKey); - HcfResult ConvertKey(const HcfBlob key, HcfSymKey **symKey); - -private: - HcfSymKeyGenerator *generator_; -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef SYM_KEY_GENERATOR_IMPL_H +#define SYM_KEY_GENERATOR_IMPL_H + +#include "ffi_remote_data.h" +#include "sym_key.h" +#include "result.h" +#include "sym_key_generator.h" +#include "log.h" + +namespace OHOS { +namespace CryptoFramework { +class SymKeyGeneratorImpl : public OHOS::FFI::FFIData { + DECL_TYPE(SymKeyGeneratorImpl, OHOS::FFI::FFIData) +public: + explicit SymKeyGeneratorImpl(HcfSymKeyGenerator *generator); + ~SymKeyGeneratorImpl(); + const char *GetAlgName(int32_t* errCode); + HcfResult GenerateSymKey(HcfSymKey **symKey); + HcfResult ConvertKey(const HcfBlob key, HcfSymKey **symKey); + +private: + HcfSymKeyGenerator *generator_; +}; +} +} + +#endif diff --git a/frameworks/cj/include/sym_key_impl.h b/frameworks/cj/include/sym_key_impl.h index 81090b6..b3effde 100644 --- a/frameworks/cj/include/sym_key_impl.h +++ b/frameworks/cj/include/sym_key_impl.h @@ -1,37 +1,37 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef SYM_KEY_IMPL_H -#define SYM_KEY_IMPL_H - -#include "ffi_remote_data.h" -#include "sym_key.h" -#include "key_impl.h" -#include "result.h" -#include "log.h" - -namespace OHOS { -namespace CryptoFramework { -class SymKeyImpl : public KeyImpl { - DECL_TYPE(SymKeyImpl, OHOS::FFI::FFIData) -public: - explicit SymKeyImpl(HcfSymKey *symKey); - ~SymKeyImpl() override; - HcfSymKey *GetSymKey() const; - void ClearMem(); -}; -} -} - -#endif +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef SYM_KEY_IMPL_H +#define SYM_KEY_IMPL_H + +#include "ffi_remote_data.h" +#include "sym_key.h" +#include "key_impl.h" +#include "result.h" +#include "log.h" + +namespace OHOS { +namespace CryptoFramework { +class SymKeyImpl : public KeyImpl { + DECL_TYPE(SymKeyImpl, OHOS::FFI::FFIData) +public: + explicit SymKeyImpl(HcfSymKey *symKey); + ~SymKeyImpl() override; + HcfSymKey *GetSymKey() const; + void ClearMem(); +}; +} +} + +#endif diff --git a/frameworks/cj/src/cipher_impl.cpp b/frameworks/cj/src/cipher_impl.cpp index 069a1c9..1ff8660 100644 --- a/frameworks/cj/src/cipher_impl.cpp +++ b/frameworks/cj/src/cipher_impl.cpp @@ -1,99 +1,99 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "cipher_impl.h" -#include "log.h" - -namespace OHOS { - namespace CryptoFramework { - CipherImpl::CipherImpl(HcfCipher *cipher) - { - cipher_ = cipher; - } - - CipherImpl::~CipherImpl() - { - HcfObjDestroy(this->cipher_); - } - - HcfResult CipherImpl::CipherInit(HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = cipher_->init(cipher_, opMode, key, params); - return res; - } - - HcfResult CipherImpl::CipherUpdate(HcfBlob *input, HcfBlob *output) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = cipher_->update(cipher_, input, output); - return res; - } - - HcfResult CipherImpl::CipherDoFinal(HcfBlob *input, HcfBlob *output) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = cipher_->doFinal(cipher_, input, output); - return res; - } - - HcfResult CipherImpl::SetCipherSpec(CipherSpecItem item, HcfBlob pSource) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_INVALID_PARAMS; - } - return cipher_->setCipherSpecUint8Array(cipher_, item, pSource); - } - - HcfResult CipherImpl::GetCipherSpecString(CipherSpecItem item, char *returnString) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_INVALID_PARAMS; - } - return cipher_->getCipherSpecString(cipher_, item, &returnString); - } - - HcfResult CipherImpl::GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - return HCF_INVALID_PARAMS; - } - return cipher_->getCipherSpecUint8Array(cipher_, item, returnUint8Array); - } - - const char *CipherImpl::GetAlgorithm(int32_t* errCode) - { - if (cipher_ == nullptr) { - LOGE("fail to get cipher obj!"); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char *algo = cipher_->getAlgorithm(cipher_); - *errCode = HCF_SUCCESS; - return algo; - } - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "cipher_impl.h" +#include "log.h" + +namespace OHOS { + namespace CryptoFramework { + CipherImpl::CipherImpl(HcfCipher *cipher) + { + cipher_ = cipher; + } + + CipherImpl::~CipherImpl() + { + HcfObjDestroy(this->cipher_); + } + + HcfResult CipherImpl::CipherInit(HcfCryptoMode opMode, HcfKey *key, HcfParamsSpec *params) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = cipher_->init(cipher_, opMode, key, params); + return res; + } + + HcfResult CipherImpl::CipherUpdate(HcfBlob *input, HcfBlob *output) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = cipher_->update(cipher_, input, output); + return res; + } + + HcfResult CipherImpl::CipherDoFinal(HcfBlob *input, HcfBlob *output) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = cipher_->doFinal(cipher_, input, output); + return res; + } + + HcfResult CipherImpl::SetCipherSpec(CipherSpecItem item, HcfBlob pSource) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_INVALID_PARAMS; + } + return cipher_->setCipherSpecUint8Array(cipher_, item, pSource); + } + + HcfResult CipherImpl::GetCipherSpecString(CipherSpecItem item, char *returnString) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_INVALID_PARAMS; + } + return cipher_->getCipherSpecString(cipher_, item, &returnString); + } + + HcfResult CipherImpl::GetCipherSpecUint8Array(CipherSpecItem item, HcfBlob *returnUint8Array) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + return HCF_INVALID_PARAMS; + } + return cipher_->getCipherSpecUint8Array(cipher_, item, returnUint8Array); + } + + const char *CipherImpl::GetAlgorithm(int32_t* errCode) + { + if (cipher_ == nullptr) { + LOGE("fail to get cipher obj!"); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char *algo = cipher_->getAlgorithm(cipher_); + *errCode = HCF_SUCCESS; + return algo; + } + } } \ No newline at end of file diff --git a/frameworks/cj/src/crypto_ffi.cpp b/frameworks/cj/src/crypto_ffi.cpp index cf19382..dd61849 100644 --- a/frameworks/cj/src/crypto_ffi.cpp +++ b/frameworks/cj/src/crypto_ffi.cpp @@ -1,1817 +1,1817 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "crypto_ffi.h" - -#define MAX_MEMORY_SIZE (5 * 1024 * 1024) - -using namespace OHOS::FFI; - -namespace OHOS { - namespace CryptoFramework { - extern "C" { - //-------------------random - int64_t FfiOHOSCreateRandom(int32_t* errCode) - { - LOGD("[Random] CreateRandom start"); - HcfRand *randObj = nullptr; - HcfResult res = HcfRandCreate(&randObj); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("create c randObj failed."); - return 0; - } - auto native = FFIData::Create(randObj); - if (!native) { - LOGE("[Random] CreateRandom failed"); - HcfObjDestroy(randObj); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Randome] CreateRandom success"); - return native->GetID(); - } - - const char *FfiOHOSRandomGetAlgName(int64_t id, int32_t* errCode) - { - LOGD("[Random] GetAlgName start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Random] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetAlgName(errCode); - LOGD("[Randome] GetAlgName success"); - return res; - } - - HcfBlob FfiOHOSGenerateRandom(int64_t id, int32_t numBytes, int32_t* errCode) - { - LOGD("[Random] GenerateRandom start"); - HcfBlob randBlob; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Random] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return randBlob; - } - randBlob = instance->GenerateRandom(numBytes, errCode); - LOGD("[Randome] GenerateRandom success"); - return randBlob; - } - - void FfiOHOSSetSeed(int64_t id, HcfBlob *seed, int32_t* errCode) - { - LOGD("[Random] SetSeed start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Random] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return; - } - instance->SetSeed(seed, errCode); - LOGD("[Randome] SetSeed success"); - } - - //--------------------- md - int64_t FfiOHOSCreateMd(char* algName, int32_t* errCode) - { - LOGD("[Md] CreateMd start"); - HcfMd *mdObj = nullptr; - HcfResult res = HcfMdCreate(algName, &mdObj); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("create c mdObj failed."); - return 0; - } - auto native = FFIData::Create(mdObj); - if (!native) { - LOGE("[Md] CreateMd failed"); - HcfObjDestroy(mdObj); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Md] CreateMd success"); - return native->GetID(); - } - - int32_t FfiOHOSMdUpdate(int64_t id, HcfBlob *input) - { - LOGD("[Md] FfiOHOSMdUpdate start"); - HcfResult res = HCF_ERR_MALLOC; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Md] instance not exist."); - return res; - } - res = instance->MdUpdate(input); - LOGD("[Md] FfiOHOSMdUpdate success"); - return res; - } - - HcfBlob FfiOHOSDigest(int64_t id, int32_t* errCode) - { - LOGD("[Md] FfiOHOSDigest start"); - auto instance = FFIData::GetData(id); - HcfBlob blob = { .data = nullptr, .len = 0}; - if (!instance) { - LOGE("[Md] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return blob; - } - HcfResult res = instance->MdDoFinal(&blob); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("doFinal failed!"); - return blob; - } - LOGD("[Md] FfiOHOSDigest success"); - return blob; - } - - uint32_t FfiOHOSGetMdLength(int64_t id, int32_t* errCode) - { - LOGD("[Md] FfiOHOSGetMdLength start"); - auto instance = FFIData::GetData(id); - uint32_t res = 0; - if (!instance) { - LOGE("[Md] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return res; - } - res = instance->GetMdLength(errCode); - LOGD("[Md] FfiOHOSGetMdLength success"); - return res; - } - - //-------------------symkeygenerator - int64_t FfiOHOSCreateSymKeyGenerator(char* algName, int32_t* errCode) - { - LOGD("[SymKeyGenerator] CreateSymKeyGenerator start"); - HcfSymKeyGenerator *generator = nullptr; - HcfResult res = HcfSymKeyGeneratorCreate(algName, &generator); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("create C generator fail."); - return 0; - } - auto native = FFIData::Create(generator); - if (native == nullptr) { - LOGE("[SymKeyGenerator] CreateSymKeyGenerator failed"); - HcfObjDestroy(generator); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[SymKeyGenerator] CreateSymKeyGenerator success"); - return native->GetID(); - } - - const char* FfiOHOSSymKeyGeneratorGetAlgName(int64_t id, int32_t* errCode) - { - LOGD("[SymKeyGenerator] GetAlgName start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKeyGenerator] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetAlgName(errCode); - LOGD("[SymKeyGenerator] GetAlgName success"); - return res; - } - - int64_t FfiOHOSGenerateSymKey(int64_t id, int32_t* errCode) - { - LOGD("[SymKeyGenerator] GenerateSymKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKeyGenerator] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return 0; - } - HcfSymKey *key = nullptr; - HcfResult res = instance->GenerateSymKey(&key); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("generate sym key failed."); - return 0; - } - auto native = FFIData::Create(key); - if (native == nullptr) { - LOGE("[SymKeyGenerator] GenerateSymKey failed"); - HcfObjDestroy(key); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[SymKeyGenerator] GenerateSymKey success"); - return native->GetID(); - } - - int64_t FfiOHOSConvertKey(int64_t id, HcfBlob *key, int32_t* errCode) - { - LOGD("[SymKeyGenerator] ConvertKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKeyGenerator] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return 0; - } - HcfSymKey *symkey = nullptr; - HcfResult res = instance->ConvertKey(*key, &symkey); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("generate sym key failed."); - return 0; - } - auto native = FFIData::Create(symkey); - if (native == nullptr) { - LOGE("[SymKeyGenerator] ConvertKey failed"); - HcfObjDestroy(key); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[SymKeyGenerator] ConvertKey success"); - return native->GetID(); - } - - //-------------------symkey - const char *FfiOHOSSymKeyGetAlgName(int64_t id, int32_t* errCode) - { - LOGD("[SymKey] GetAlgName start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetAlgorithm(errCode); - LOGD("[SymKey] GetAlgName success"); - return res; - } - - const char *FfiOHOSSymKeyGetFormat(int64_t id, int32_t* errCode) - { - LOGD("[SymKey] GetFormat start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetFormat(errCode); - LOGD("[SymKey] GetFormat success"); - return res; - } - - int32_t FfiOHOSSymKeyGetEncoded(int64_t id, HcfBlob *returnBlob) - { - LOGD("[SymKey] GetEncoded start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfResult res = instance->GetEncoded(returnBlob); - LOGD("[SymKey] GetEncoded success"); - return res; - } - - void FfiOHOSClearMem(int64_t id) - { - LOGD("[SymKey] ClearMem start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - return; - } - instance->ClearMem(); - LOGD("[SymKey] ClearMem success"); - } - - void* FfiOHOSSymKeyGetHcfKey(int64_t id) - { - LOGD("[SymKey] GetHcfKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - return nullptr; - } - HcfKey *key = instance->GetHcfKey(); - LOGD("[SymKey] GetHcfKey success"); - return key; - } - - // cipher - const std::string IV_PARAMS_SPEC = "IvParamsSpec"; - const std::string GCM_PARAMS_SPEC = "GcmParamsSpec"; - const std::string CCM_PARAMS_SPEC = "CcmParamsSpec"; - const size_t GCM_AUTH_TAG_LEN = 16; - const size_t CCM_AUTH_TAG_LEN = 12; - static const char *GetIvParamsSpecType() - { - return IV_PARAMS_SPEC.c_str(); - } - - static const char *GetGcmParamsSpecType() - { - return GCM_PARAMS_SPEC.c_str(); - } - - static const char *GetCcmParamsSpecType() - { - return CCM_PARAMS_SPEC.c_str(); - } - - void *HcfMalloc(uint32_t size, char val) - { - if ((size == 0) || (size > MAX_MEMORY_SIZE)) { - LOGE("malloc size is invalid"); - return nullptr; - } - void *addr = malloc(size); - if (addr != nullptr) { - (void)memset_s(addr, size, val, size); - } - return addr; - } - - void HcfFree(void *addr) - { - if (addr != nullptr) { - free(addr); - } - } - - int64_t FfiOHOSCreateCipher(char* transformation, int32_t* errCode) - { - LOGD("[Cipher] CreateCipher start"); - HcfCipher *cipher = nullptr; - HcfResult res = HcfCipherCreate(transformation, &cipher); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("create C cipher fail!"); - return 0; - } - auto native = FFIData::Create(cipher); - if (native == nullptr) { - LOGE("[Cipher] CreateCipher failed"); - HcfObjDestroy(cipher); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Cipher] CreateCipher success"); - return native->GetID(); - } - - int32_t FfiOHOSCipherInitByIv(int64_t id, int32_t opMode, void* key, HcfBlob blob1) - { - LOGD("[Cipher] FfiOHOSCipherInitByIv start"); - if (key == nullptr) { - LOGE("[Cipher] key can not be nullptr."); - return HCF_INVALID_PARAMS; - } - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfIvParamsSpec *ivParamsSpec = reinterpret_cast( - HcfMalloc(sizeof(HcfIvParamsSpec), 0)); - if (ivParamsSpec == nullptr) { - LOGE("ivParamsSpec malloc failed!"); - return HCF_INVALID_PARAMS; - } - ivParamsSpec->base.getType = GetIvParamsSpecType; - ivParamsSpec->iv = blob1; - HcfCryptoMode mode = HcfCryptoMode(opMode); - HcfParamsSpec *paramsSpec = reinterpret_cast(ivParamsSpec); - ivParamsSpec = nullptr; - HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); - HcfFree(paramsSpec); - paramsSpec = nullptr; - LOGD("[Cipher] FfiOHOSCipherInitByIv success"); - return res; - } - - int32_t FfiOHOSCipherInitByGcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec) - { - LOGD("[Cipher] FfiOHOSCipherInitByGcm start"); - if (key == nullptr) { - LOGE("[Cipher] key can not be nullptr."); - return HCF_INVALID_PARAMS; - } - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfGcmParamsSpec *gcmParamsSpec = reinterpret_cast( - HcfMalloc(sizeof(HcfGcmParamsSpec), 0)); - if (gcmParamsSpec == nullptr) { - LOGE("gcmParamsSpec malloc failed!"); - return HCF_INVALID_PARAMS; - } - HcfCryptoMode mode = HcfCryptoMode(opMode); - HcfBlob authTag = {}; - if (mode == DECRYPT_MODE) { - gcmParamsSpec->tag = spec.authTag; - } else if (mode == ENCRYPT_MODE) { - authTag.data = static_cast(HcfMalloc(GCM_AUTH_TAG_LEN, 0)); - if (authTag.data == nullptr) { - HcfFree(gcmParamsSpec); - return HCF_INVALID_PARAMS; - } - authTag.len = GCM_AUTH_TAG_LEN; - gcmParamsSpec->tag = authTag; - } - gcmParamsSpec->base.getType = GetGcmParamsSpecType; - gcmParamsSpec->iv = spec.iv; - gcmParamsSpec->aad = spec.add; - HcfParamsSpec *paramsSpec = reinterpret_cast(gcmParamsSpec); - gcmParamsSpec = nullptr; - HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); - HcfBlobDataFree(&authTag); - HcfFree(paramsSpec); - paramsSpec = nullptr; - LOGD("[Cipher] FfiOHOSCipherInitByGcm success"); - return res; - } - - int32_t FfiOHOSCipherInitByCcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec) - { - LOGD("[Cipher] FfiOHOSCipherInitByCcm start"); - if (key == nullptr) { - LOGE("[Cipher] key can not be nullptr."); - return HCF_INVALID_PARAMS; - } - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfCcmParamsSpec *ccmParamsSpec = reinterpret_cast( - HcfMalloc(sizeof(HcfCcmParamsSpec), 0)); - if (ccmParamsSpec == nullptr) { - LOGE("ccmParamsSpec malloc failed!"); - return HCF_INVALID_PARAMS; - } - HcfBlob authTag = {}; - HcfCryptoMode mode = HcfCryptoMode(opMode); - if (mode == DECRYPT_MODE) { - ccmParamsSpec->tag = spec.authTag; - } else if (mode == ENCRYPT_MODE) { - authTag.data = static_cast(HcfMalloc(CCM_AUTH_TAG_LEN, 0)); - if (authTag.data == nullptr) { - HcfFree(ccmParamsSpec); - return HCF_INVALID_PARAMS; - } - authTag.len = CCM_AUTH_TAG_LEN; - ccmParamsSpec->tag = authTag; - } - ccmParamsSpec->base.getType = GetCcmParamsSpecType; - ccmParamsSpec->iv = spec.iv; - ccmParamsSpec->aad = spec.add; - HcfParamsSpec *paramsSpec = reinterpret_cast(ccmParamsSpec); - ccmParamsSpec = nullptr; - HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); - HcfBlobDataFree(&authTag); - HcfFree(paramsSpec); - paramsSpec = nullptr; - LOGD("[Cipher] FfiOHOSCipherInitByCcm success"); - return res; - } - - int32_t FfiOHOSCipherInitWithOutParams(int64_t id, int32_t opMode, void* key) - { - LOGD("[Cipher] FfiOHOSCipherInitWithOutParams start"); - if (key == nullptr) { - LOGE("[Cipher] key can not be nullptr."); - return HCF_INVALID_PARAMS; - } - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfParamsSpec *paramsSpec = nullptr; - HcfCryptoMode mode = HcfCryptoMode(opMode); - HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); - LOGD("[Cipher] FfiOHOSCipherInitWithOutParams success"); - return res; - } - - int32_t FfiOHOSCipherUpdate(int64_t id, HcfBlob *input, HcfBlob *output) - { - LOGD("[Cipher] CipherUpdate start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfResult res = instance->CipherUpdate(input, output); - LOGD("[Cipher] CipherUpdate success"); - return res; - } - - int32_t FfiOHOSCipherDoFinal(int64_t id, HcfBlob *input, HcfBlob *output) - { - LOGD("[Cipher] CipherDoFinal start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - HcfResult res = instance->CipherDoFinal(input, output); - LOGD("[Cipher] CipherDoFinal success %{public}d", res); - return res; - } - - int32_t FfiOHOSSetCipherSpec(int64_t id, int32_t item, HcfBlob pSource) - { - LOGD("[Cipher] SetCipherSpec start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - CipherSpecItem csi = CipherSpecItem(item); - HcfResult res = instance->SetCipherSpec(csi, pSource); - LOGD("[Cipher] SetCipherSpec success"); - return res; - } - - int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString) - { - LOGD("[Cipher] GetCipherSpecString start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - CipherSpecItem csi = CipherSpecItem(item); - HcfResult res = instance->GetCipherSpecString(csi, returnString); - LOGD("[Cipher] GetCipherSpecString success"); - return res; - } - - int32_t FfiOHOSGetCipherSpecUint8Array(int64_t id, int32_t item, HcfBlob *returnUint8Array) - { - LOGD("[Cipher] GetCipherSpecUint8Array start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Cipher] instance not exist."); - return HCF_ERR_MALLOC; - } - CipherSpecItem csi = CipherSpecItem(item); - HcfResult res = instance->GetCipherSpecUint8Array(csi, returnUint8Array); - LOGD("[Cipher] GetCipherSpecUint8Array success"); - return res; - } - - const char *FfiOHOSCipherGetAlgName(int64_t id, int32_t* errCode) - { - LOGD("[Cipher] GetAlgName start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[SymKey] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetAlgorithm(errCode); - LOGD("[Cipher] GetAlgName success"); - return res; - } - - //--------------------- mac - int64_t FFiOHOSCryptoMacConstructor(char* algName, int32_t* errCode) - { - LOGD("[Mac] CreateMac start"); - HcfMac *macObj = nullptr; - HcfResult res = HcfMacCreate(algName, &macObj); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("create c macObj failed."); - return 0; - } - auto native = FFIData::Create(macObj); - if (native == nullptr) { - LOGE("[Mac] CreateMac failed"); - HcfObjDestroy(macObj); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Mac] CreateMac success"); - return native->GetID(); - } - - int32_t FfiOHOSCryptoMacInit(int64_t id, int64_t symKeyId) - { - LOGD("[MAC] FfiOHOSCryptoMacInit start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[MAC] MacImpl instance not exist."); - return HCF_ERR_MALLOC; - } - - auto keyInstance = FFIData::GetData(symKeyId); - if (!instance) { - LOGE("[MAC] SymKeyImpl instance not exist."); - return HCF_ERR_MALLOC; - } - - HcfResult res = instance->MacInit(keyInstance->GetSymKey()); - if (res != HCF_SUCCESS) { - LOGE("[MAC] MacInit error %{public}d", res); - } else { - LOGD("[MAC] FfiOHOSCryptoMacInit success"); - } - - return res; - } - - int32_t FfiOHOSCryptoMacUpdate(int64_t id, HcfBlob *input) - { - LOGD("[Mac] FfiOHOSCryptoMacUpdate start"); - HcfResult res = HCF_ERR_MALLOC; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[Mac] instance not exist."); - return res; - } - res = instance->MacUpdate(input); - LOGD("[Mac] FfiOHOSCryptoMacUpdate success"); - return res; - } - - HcfBlob FfiOHOSCryptoMacDoFinal(int64_t id, int32_t* errCode) - { - LOGD("[Mac] FfiOHOSCryptoMacDoFinal start"); - auto instance = FFIData::GetData(id); - HcfBlob blob = { .data = nullptr, .len = 0}; - if (!instance) { - LOGE("[Mac] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return blob; - } - HcfResult res = instance->MacDoFinal(&blob); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("doFinal failed!"); - return blob; - } - LOGD("[Mac] FfiOHOSCryptoMacDoFinal success"); - return blob; - } - - uint32_t FfiOHOSCryptoGetMacLength(int64_t id) - { - LOGD("[Mac] FfiOHOSGCryptoGetMacLength start"); - auto instance = FFIData::GetData(id); - uint32_t res = 0; - if (!instance) { - LOGE("[Mac] instance not exist."); - return res; - } - res = instance->GetMacLength(); - LOGD("[Mac] FfiOHOSGCryptoGetMacLength success"); - return res; - } - - //--------------------- sign - int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode) - { - LOGD("[Sign] FFiOHOSCryptoSignConstructor start"); - HcfSign *signObj = nullptr; - HcfResult res = HcfSignCreate(algName, &signObj); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("[Sign] FFiOHOSCryptoSignConstructor create c signObj failed."); - return 0; - } - auto native = FFIData::Create(signObj); - if (native == nullptr) { - LOGE("[Sign] FFiOHOSCryptoSignConstructor create failed"); - HcfObjDestroy(signObj); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Sign] FFiOHOSCryptoSignConstructor success"); - return native->GetID(); - } - - int32_t FFiOHOSSignInit(int64_t sid, int64_t pid) - { - LOGD("[Sign] FFiOHOSSignInit start"); - auto sign = FFIData::GetData(sid); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignInit failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - auto priKeyImpl = FFIData::GetData(pid); - if (priKeyImpl == nullptr) { - LOGE("[Sign] FFiOHOSSignInit failed to get priKeyImpl obj."); - return HCF_INVALID_PARAMS; - } - HcfPriKey *priKey = priKeyImpl->GetPriKey(); - if (priKey == nullptr) { - LOGE("[Sign] FFiOHOSSignInit failed to get priKey obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignInit success"); - return sign->Init(priKey); - } - - int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input) - { - LOGD("[Sign] FFiOHOSSignUpdate start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignUpdate failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignUpdate success"); - return sign->Update(&input); - } - - int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output) - { - LOGD("[Sign] FFiOHOSSignSign start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignSign failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignSign success"); - return sign->Sign(input, output); - } - - int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue) - { - LOGD("[Sign] FFiOHOSSignSetSignSpecByNum start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignSetSignSpecByNum failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignSetSignSpecByNum success"); - return sign->SetSignSpecByNum(itemValue); - } - - int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue) - { - LOGD("[Sign] FFiOHOSSignSetSignSpecByArr start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignSetSignSpecByArr failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignSetSignSpecByArr success"); - return sign->SetSignSpecByArr(itemValue); - } - - int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue) - { - LOGD("[Sign] FFiOHOSSignGetSignSpecString start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignGetSignSpecString failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignGetSignSpecString success"); - return sign->GetSignSpecString(item, itemValue); - } - - int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) - { - LOGD("[Sign] FFiOHOSSignGetSignSpecNum start"); - auto sign = FFIData::GetData(id); - if (sign == nullptr) { - LOGE("[Sign] FFiOHOSSignGetSignSpecNum failed to get sign obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Sign] FFiOHOSSignGetSignSpecNum success"); - return sign->GetSignSpecNum(item, itemValue); - } - - //--------------------- verify - int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode) - { - LOGD("[Verify]FFiOHOSVerifyConstructor start"); - HcfVerify *verify = nullptr; - HcfResult res = HcfVerifyCreate(algName, &verify); - *errCode = static_cast(res); - if (res != HCF_SUCCESS) { - LOGE("[Verify] FFiOHOSVerifyConstructor create c verifyObj failed."); - return 0; - } - auto native = FFIData::Create(verify); - if (native == nullptr) { - LOGE("[Verify] FFiOHOSVerifyConstructor create failed"); - HcfObjDestroy(verify); - *errCode = HCF_ERR_MALLOC; - return 0; - } - LOGD("[Verify] FFiOHOSVerifyConstructor success"); - return native->GetID(); - } - - int32_t FFiOHOSVerifyInit(int64_t sid, int64_t pid) - { - LOGD("[Verify] FFiOHOSVerifyInit start"); - auto verify = FFIData::GetData(sid); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyInit failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - auto pubKeyImpl = FFIData::GetData(pid); - if (pubKeyImpl == nullptr) { - LOGE("[Verify] FFiOHOSVerifyInit failed to get priKeyImpl obj."); - return HCF_INVALID_PARAMS; - } - HcfPubKey *pubKey = pubKeyImpl->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[Verify] FFiOHOSVerifyInit failed to get priKey obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyInit success"); - return verify->Init(pubKey); - } - - int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input) - { - LOGD("[Verify] FFiOHOSVerifyUpdate start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyUpdate failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyUpdate success"); - return verify->Update(&input); - } - - bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode) - { - LOGD("[Verify] FFiOHOSVerifyVerify start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyVerify success"); - return verify->Verify(data, signatureData, errCode); - } - - int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output) - { - LOGD("[Verify] FFiOHOSVerifyRecover start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyRecover success"); - return verify->Recover(input, output); - } - - - int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue) - { - LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifySetVerifySpecByNum failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum success"); - return verify->SetVerifySpecByNum(itemValue); - } - - int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue) - { - LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifySetVerifySpecByArr failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr success"); - return verify->SetVerifySpecByArr(itemValue); - } - - int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue) - { - LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyGetVerifySpecString failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString success"); - return verify->GetVerifySpecString(item, itemValue); - } - - int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) - { - LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum start"); - auto verify = FFIData::GetData(id); - if (verify == nullptr) { - LOGE("[Verify] FFiOHOSVerifyGetVerifySpecNum failed to get verify obj."); - return HCF_INVALID_PARAMS; - } - LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum success"); - return verify->GetVerifySpecNum(item, itemValue); - } - - //--------------------- asykeygenerator - int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode) - { - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor start"); - HcfAsyKeyGenerator *generator = nullptr; - *errCode = HcfAsyKeyGeneratorCreate(algName, &generator); - if (*errCode != HCF_SUCCESS) { - *errCode = HCF_INVALID_PARAMS; - LOGE("create c generator fail."); - return 0; - } - auto instance = FFIData::Create(generator); - if (!instance) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(generator); - LOGE("new asy key generator failed"); - return 0; - } - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor end"); - return instance->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode) - { - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfKeyPair *returnKeyPair = nullptr; - HcfParamsSpec *params = nullptr; - *errCode = generator->generateKeyPair(generator, params, &returnKeyPair); - if (*errCode != HCF_SUCCESS) { - LOGD("generate key pair fail."); - return 0; - } - auto keyPair = FFIData::Create(returnKeyPair); - if (keyPair == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnKeyPair); - LOGE("new key pair failed"); - return 0; - } - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair end"); - return keyPair->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode) - { - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfKeyPair *returnKeyPair = nullptr; - HcfParamsSpec *params = nullptr; - *errCode = generator->convertKey(generator, params, pubKey, priKey, &returnKeyPair); - if (*errCode != HCF_SUCCESS) { - LOGD("convert key fail."); - return 0; - } - auto keyPair = FFIData::Create(returnKeyPair); - if (keyPair == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnKeyPair); - LOGE("new key pair failed"); - return 0; - } - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey end"); - return keyPair->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode) - { - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfKeyPair *returnKeyPair = nullptr; - HcfParamsSpec *params = nullptr; - *errCode = generator->convertPemKey(generator, params, pubKey, priKey, &returnKeyPair); - if (*errCode != HCF_SUCCESS) { - LOGE("ConvertPemKey fail."); - return 0; - } - auto keyPair = FFIData::Create(returnKeyPair); - if (keyPair == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnKeyPair); - LOGE("new key pair failed"); - return 0; - } - LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey end"); - return keyPair->GetID(); - } - - //--------------------- asykeyspecgenerator - int64_t AsyKeyGeneratorBySpecConstructor(HcfAsyKeyParamsSpec *asyKeySpec, int32_t *errCode) - { - HcfAsyKeyGeneratorBySpec *generator = nullptr; - *errCode = HcfAsyKeyGeneratorBySpecCreate(asyKeySpec, &generator); - if (*errCode != HCF_SUCCESS) { - *errCode = HCF_INVALID_PARAMS; - LOGE("create C generator by sepc fail."); - return 0; - } - auto instance = FFIData::Create(generator); - if (!instance) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(generator); - LOGE("new asy key generator by spec failed!"); - return 0; - } - return instance->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec(HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpecc end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec start"); - HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); - int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec end"); - return id; - } - - int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfKeyPair *returnKeyPair = nullptr; - *errCode = generator->generateKeyPair(generator, &returnKeyPair); - if (*errCode != HCF_SUCCESS) { - LOGD("generate key pair fail."); - return 0; - } - auto keyPair = FFIData::Create(returnKeyPair); - if (keyPair == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnKeyPair); - LOGE("new key pair failed"); - return 0; - } - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair end"); - return keyPair->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfPriKey *returnPriKey = nullptr; - *errCode = generator->generatePriKey(generator, &returnPriKey); - if (*errCode != HCF_SUCCESS) { - LOGD("generate PriKey fail."); - return 0; - } - auto priKey = FFIData::Create(returnPriKey); - if (priKey == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnPriKey); - LOGE("new pri key failed"); - return 0; - } - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey end"); - return priKey->GetID(); - } - - int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode) - { - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); - if (generator == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build generator fail."); - return 0; - } - HcfPubKey *returnPubKey = nullptr; - *errCode = generator->generatePubKey(generator, &returnPubKey); - if (*errCode != HCF_SUCCESS) { - LOGD("generate PubKey fail."); - return 0; - } - auto pubKey = FFIData::Create(returnPubKey); - if (pubKey == nullptr) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(returnPubKey); - LOGE("new pub key failed"); - return 0; - } - LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey end"); - return pubKey->GetID(); - } - - //--------------------- prikey - HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetEncoded start"); - HcfBlob ret = { .data = nullptr, .len = 0 }; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = priKey->base.getEncoded(&priKey->base, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetEncoded end"); - return ret; - } - - HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer start"); - HcfBlob ret = { .data = nullptr, .len = 0 }; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = priKey->getEncodedDer(priKey, format, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer end"); - return ret; - } - - char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem start"); - char *ret = nullptr; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = priKey->base.getEncodedPem(&priKey->base, format, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem end"); - return ret; - } - - int32_t FFiOHOSPriKeyClearMem(int64_t id) - { - LOGD("[PriKey] FFiOHOSPriKeyClearMem start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to unwrap private key obj!"); - return HCF_INVALID_PARAMS; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to get private key obj!"); - return HCF_INVALID_PARAMS; - } - priKey->clearMem(priKey); - LOGD("[PriKey] FFiOHOSPriKeyClearMem end"); - return HCF_SUCCESS; - } - - int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - int ret = 0; - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = priKey->getAsyKeySpecInt(priKey, item, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); - return ret; - } - - char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - char *ret = nullptr; - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = priKey->getAsyKeySpecString(priKey, item, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); - return ret; - } - - HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - HcfBigInteger ret = { 0 }; - if (!instance) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPriKey *priKey = instance->GetPriKey(); - if (priKey == nullptr) { - LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = priKey->getAsyKeySpecBigInteger(priKey, item, &ret); - LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); - return ret; - } - - const char *FfiOHOSPriKeyGetFormat(int64_t id, int32_t* errCode) - { - LOGD("[PriKey] GetFormat start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PriKey] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetFormat(errCode); - LOGD("[PriKey] GetFormat success"); - return res; - } - - //--------------------- pubkey - HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetEncoded start"); - HcfBlob ret = { .data = nullptr, .len = 0 }; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = pubKey->base.getEncoded(&pubKey->base, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetEncoded end"); - return ret; - } - - HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer start"); - HcfBlob ret = { .data = nullptr, .len = 0 }; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = pubKey->getEncodedDer(pubKey, format, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer end"); - return ret; - } - - char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem start"); - char *ret = nullptr; - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - *errCode = pubKey->base.getEncodedPem(&pubKey->base, format, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem end"); - return ret; - } - - int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - int ret = 0; - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = pubKey->getAsyKeySpecInt(pubKey, item, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); - return ret; - } - - char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - char *ret = nullptr; - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = pubKey->getAsyKeySpecString(pubKey, item, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); - return ret; - } - - HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) - { - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); - auto instance = FFIData::GetData(id); - HcfBigInteger ret = { 0 }; - if (!instance) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - HcfPubKey *pubKey = instance->GetPubKey(); - if (pubKey == nullptr) { - LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); - *errCode = HCF_INVALID_PARAMS; - return ret; - } - AsyKeySpecItem item = AsyKeySpecItem(itemType); - *errCode = pubKey->getAsyKeySpecBigInteger(pubKey, item, &ret); - LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); - return ret; - } - - const char *FfiOHOSPubKeyGetFormat(int64_t id, int32_t* errCode) - { - LOGD("[PubKey] GetFormat start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] instance not exist."); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char* res = instance->GetFormat(errCode); - LOGD("[PubKey] GetFormat success"); - return res; - } - - // ------------------------------------keypair - int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode) - { - LOGD("[KeyPair] FFiOHOSKeyPairPubKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfKeyPair *keyPair = instance->GetHcfKeyPair(); - if (keyPair == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("get keyPair fail."); - return 0; - } - HcfPubKey *pubKey = keyPair->pubKey; - if (pubKey == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("get pubKey fail."); - return 0; - } - auto pub = FFIData::Create(pubKey); - if (pub == nullptr) { - *errCode = HCF_ERR_MALLOC; - LOGE("new pub key failed"); - return 0; - } - LOGD("[KeyPair] FFiOHOSKeyPairPubKey end"); - return pub->GetID(); - } - - int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode) - { - LOGD("[KeyPair] FFiOHOSKeyPairPriKey start"); - auto instance = FFIData::GetData(id); - if (!instance) { - *errCode = HCF_INVALID_PARAMS; - LOGE("build instance fail."); - return 0; - } - HcfKeyPair *keyPair = instance->GetHcfKeyPair(); - if (keyPair == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("get keyPair fail."); - return 0; - } - HcfPriKey *priKey = keyPair->priKey; - if (priKey == nullptr) { - *errCode = HCF_INVALID_PARAMS; - LOGE("get priKey fail."); - return 0; - } - auto pri = FFIData::Create(priKey); - if (pri == nullptr) { - *errCode = HCF_ERR_MALLOC; - LOGE("new pri key failed"); - return 0; - } - LOGD("[KeyPair] FFiOHOSKeyPairPriKey end"); - return pri->GetID(); - } - - // ------------------------------------kdf - int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode) - { - LOGD("[Kdf] FFiOHOSKdfConstructor start"); - HcfKdf *kdf = nullptr; - *errCode = HcfKdfCreate(algName, &kdf); - if (*errCode != HCF_SUCCESS) { - *errCode = HCF_INVALID_PARAMS; - LOGE("create c kdf fail."); - return 0; - } - auto instance = FFIData::Create(kdf); - if (!instance) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(kdf); - LOGE("new kdf failed!"); - return 0; - } - LOGD("[Kdf] FFiOHOSKdfConstructor end"); - return instance->GetID(); - } - - int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params) - { - LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] FiOHOSKdfGenerateSecretByPB failed to get kdf impl obj!"); - return HCF_INVALID_PARAMS; - } - HcfKdfParamsSpec *tmp = reinterpret_cast(params); - LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB end"); - return instance->GenerateSecret(tmp); - } - - int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params) - { - LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH start"); - auto instance = FFIData::GetData(id); - if (!instance) { - LOGE("[PubKey] F FFiOHOSKdfGenerateSecretByH failed to get kdf impl obj!"); - return HCF_INVALID_PARAMS; - } - HcfKdfParamsSpec *tmp = reinterpret_cast(params); - LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH end"); - return instance->GenerateSecret(tmp); - } - - // --------------------------ecc_key_util - HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode) - { - return ECCKeyUtilImpl::GenECCCommonParamsSpec(curveName, errCode); - } - - HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode) - { - return ECCKeyUtilImpl::ConvertPoint(curveName, encodedPoint, errCode); - } - - HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint(char *curveName, HcfPoint point, char *format, int32_t *errCode) - { - return ECCKeyUtilImpl::GetEncodedPoint(curveName, point, format, errCode); - } - - // ---------------------------keyagreement - int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode) - { - LOGD("[KeyAgreement] FFiOHOSKdfConstructor start"); - HcfKeyAgreement *keyAgreement = nullptr; - *errCode = HcfKeyAgreementCreate(algName, &keyAgreement); - if (*errCode != HCF_SUCCESS) { - *errCode = HCF_INVALID_PARAMS; - LOGE("create c keyAgreement fail."); - return 0; - } - auto instance = FFIData::Create(keyAgreement); - if (!instance) { - *errCode = HCF_ERR_MALLOC; - HcfObjDestroy(keyAgreement); - LOGE("new key agreement failed!"); - return 0; - } - LOGD("[KeyAgreement] FFiOHOSKdfConstructor end"); - return instance->GetID(); - } - - HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode) - { - LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret start"); - auto instance = FFIData::GetData(id); - HcfBlob blob = { 0 }; - if (!instance) { - LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get key agreement obj!"); - *errCode = HCF_INVALID_PARAMS; - return blob; - } - auto priKey = FFIData::GetData(priId); - if (!priKey) { - LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); - *errCode = HCF_INVALID_PARAMS; - return blob; - } - auto pubKey = FFIData::GetData(pubId); - if (!pubKey) { - LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); - *errCode = HCF_INVALID_PARAMS; - return blob; - } - LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret end"); - return instance->GenerateSecret(priKey->GetPriKey(), pubKey->GetPubKey(), errCode); - } - - // dh_key_util - HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec(int32_t pLen, int32_t skLen, int32_t *errCode) - { - return DHKeyUtilImpl::GenDHCommonParamsSpec(pLen, skLen, errCode); - } - - // sm2_crypto_util - HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode) - { - return Sm2CryptoUtilImpl::GenCipherTextBySpec(spec, mode, errCode); - } - - Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode) - { - return Sm2CryptoUtilImpl::GetCipherTextSpec(input, mode, errCode); - } - } - } // namespace CryptoFramework +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "crypto_ffi.h" + +#define MAX_MEMORY_SIZE (5 * 1024 * 1024) + +using namespace OHOS::FFI; + +namespace OHOS { + namespace CryptoFramework { + extern "C" { + //-------------------random + int64_t FfiOHOSCreateRandom(int32_t* errCode) + { + LOGD("[Random] CreateRandom start"); + HcfRand *randObj = nullptr; + HcfResult res = HcfRandCreate(&randObj); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("create c randObj failed."); + return 0; + } + auto native = FFIData::Create(randObj); + if (!native) { + LOGE("[Random] CreateRandom failed"); + HcfObjDestroy(randObj); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Randome] CreateRandom success"); + return native->GetID(); + } + + const char *FfiOHOSRandomGetAlgName(int64_t id, int32_t* errCode) + { + LOGD("[Random] GetAlgName start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Random] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetAlgName(errCode); + LOGD("[Randome] GetAlgName success"); + return res; + } + + HcfBlob FfiOHOSGenerateRandom(int64_t id, int32_t numBytes, int32_t* errCode) + { + LOGD("[Random] GenerateRandom start"); + HcfBlob randBlob; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Random] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return randBlob; + } + randBlob = instance->GenerateRandom(numBytes, errCode); + LOGD("[Randome] GenerateRandom success"); + return randBlob; + } + + void FfiOHOSSetSeed(int64_t id, HcfBlob *seed, int32_t* errCode) + { + LOGD("[Random] SetSeed start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Random] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return; + } + instance->SetSeed(seed, errCode); + LOGD("[Randome] SetSeed success"); + } + + //--------------------- md + int64_t FfiOHOSCreateMd(char* algName, int32_t* errCode) + { + LOGD("[Md] CreateMd start"); + HcfMd *mdObj = nullptr; + HcfResult res = HcfMdCreate(algName, &mdObj); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("create c mdObj failed."); + return 0; + } + auto native = FFIData::Create(mdObj); + if (!native) { + LOGE("[Md] CreateMd failed"); + HcfObjDestroy(mdObj); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Md] CreateMd success"); + return native->GetID(); + } + + int32_t FfiOHOSMdUpdate(int64_t id, HcfBlob *input) + { + LOGD("[Md] FfiOHOSMdUpdate start"); + HcfResult res = HCF_ERR_MALLOC; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Md] instance not exist."); + return res; + } + res = instance->MdUpdate(input); + LOGD("[Md] FfiOHOSMdUpdate success"); + return res; + } + + HcfBlob FfiOHOSDigest(int64_t id, int32_t* errCode) + { + LOGD("[Md] FfiOHOSDigest start"); + auto instance = FFIData::GetData(id); + HcfBlob blob = { .data = nullptr, .len = 0}; + if (!instance) { + LOGE("[Md] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return blob; + } + HcfResult res = instance->MdDoFinal(&blob); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("doFinal failed!"); + return blob; + } + LOGD("[Md] FfiOHOSDigest success"); + return blob; + } + + uint32_t FfiOHOSGetMdLength(int64_t id, int32_t* errCode) + { + LOGD("[Md] FfiOHOSGetMdLength start"); + auto instance = FFIData::GetData(id); + uint32_t res = 0; + if (!instance) { + LOGE("[Md] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return res; + } + res = instance->GetMdLength(errCode); + LOGD("[Md] FfiOHOSGetMdLength success"); + return res; + } + + //-------------------symkeygenerator + int64_t FfiOHOSCreateSymKeyGenerator(char* algName, int32_t* errCode) + { + LOGD("[SymKeyGenerator] CreateSymKeyGenerator start"); + HcfSymKeyGenerator *generator = nullptr; + HcfResult res = HcfSymKeyGeneratorCreate(algName, &generator); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("create C generator fail."); + return 0; + } + auto native = FFIData::Create(generator); + if (native == nullptr) { + LOGE("[SymKeyGenerator] CreateSymKeyGenerator failed"); + HcfObjDestroy(generator); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[SymKeyGenerator] CreateSymKeyGenerator success"); + return native->GetID(); + } + + const char* FfiOHOSSymKeyGeneratorGetAlgName(int64_t id, int32_t* errCode) + { + LOGD("[SymKeyGenerator] GetAlgName start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKeyGenerator] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetAlgName(errCode); + LOGD("[SymKeyGenerator] GetAlgName success"); + return res; + } + + int64_t FfiOHOSGenerateSymKey(int64_t id, int32_t* errCode) + { + LOGD("[SymKeyGenerator] GenerateSymKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKeyGenerator] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return 0; + } + HcfSymKey *key = nullptr; + HcfResult res = instance->GenerateSymKey(&key); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("generate sym key failed."); + return 0; + } + auto native = FFIData::Create(key); + if (native == nullptr) { + LOGE("[SymKeyGenerator] GenerateSymKey failed"); + HcfObjDestroy(key); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[SymKeyGenerator] GenerateSymKey success"); + return native->GetID(); + } + + int64_t FfiOHOSConvertKey(int64_t id, HcfBlob *key, int32_t* errCode) + { + LOGD("[SymKeyGenerator] ConvertKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKeyGenerator] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return 0; + } + HcfSymKey *symkey = nullptr; + HcfResult res = instance->ConvertKey(*key, &symkey); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("generate sym key failed."); + return 0; + } + auto native = FFIData::Create(symkey); + if (native == nullptr) { + LOGE("[SymKeyGenerator] ConvertKey failed"); + HcfObjDestroy(key); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[SymKeyGenerator] ConvertKey success"); + return native->GetID(); + } + + //-------------------symkey + const char *FfiOHOSSymKeyGetAlgName(int64_t id, int32_t* errCode) + { + LOGD("[SymKey] GetAlgName start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetAlgorithm(errCode); + LOGD("[SymKey] GetAlgName success"); + return res; + } + + const char *FfiOHOSSymKeyGetFormat(int64_t id, int32_t* errCode) + { + LOGD("[SymKey] GetFormat start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetFormat(errCode); + LOGD("[SymKey] GetFormat success"); + return res; + } + + int32_t FfiOHOSSymKeyGetEncoded(int64_t id, HcfBlob *returnBlob) + { + LOGD("[SymKey] GetEncoded start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfResult res = instance->GetEncoded(returnBlob); + LOGD("[SymKey] GetEncoded success"); + return res; + } + + void FfiOHOSClearMem(int64_t id) + { + LOGD("[SymKey] ClearMem start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + return; + } + instance->ClearMem(); + LOGD("[SymKey] ClearMem success"); + } + + void* FfiOHOSSymKeyGetHcfKey(int64_t id) + { + LOGD("[SymKey] GetHcfKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + return nullptr; + } + HcfKey *key = instance->GetHcfKey(); + LOGD("[SymKey] GetHcfKey success"); + return key; + } + + // cipher + const std::string IV_PARAMS_SPEC = "IvParamsSpec"; + const std::string GCM_PARAMS_SPEC = "GcmParamsSpec"; + const std::string CCM_PARAMS_SPEC = "CcmParamsSpec"; + const size_t GCM_AUTH_TAG_LEN = 16; + const size_t CCM_AUTH_TAG_LEN = 12; + static const char *GetIvParamsSpecType() + { + return IV_PARAMS_SPEC.c_str(); + } + + static const char *GetGcmParamsSpecType() + { + return GCM_PARAMS_SPEC.c_str(); + } + + static const char *GetCcmParamsSpecType() + { + return CCM_PARAMS_SPEC.c_str(); + } + + void *HcfMalloc(uint32_t size, char val) + { + if ((size == 0) || (size > MAX_MEMORY_SIZE)) { + LOGE("malloc size is invalid"); + return nullptr; + } + void *addr = malloc(size); + if (addr != nullptr) { + (void)memset_s(addr, size, val, size); + } + return addr; + } + + void HcfFree(void *addr) + { + if (addr != nullptr) { + free(addr); + } + } + + int64_t FfiOHOSCreateCipher(char* transformation, int32_t* errCode) + { + LOGD("[Cipher] CreateCipher start"); + HcfCipher *cipher = nullptr; + HcfResult res = HcfCipherCreate(transformation, &cipher); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("create C cipher fail!"); + return 0; + } + auto native = FFIData::Create(cipher); + if (native == nullptr) { + LOGE("[Cipher] CreateCipher failed"); + HcfObjDestroy(cipher); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Cipher] CreateCipher success"); + return native->GetID(); + } + + int32_t FfiOHOSCipherInitByIv(int64_t id, int32_t opMode, void* key, HcfBlob blob1) + { + LOGD("[Cipher] FfiOHOSCipherInitByIv start"); + if (key == nullptr) { + LOGE("[Cipher] key can not be nullptr."); + return HCF_INVALID_PARAMS; + } + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfIvParamsSpec *ivParamsSpec = reinterpret_cast( + HcfMalloc(sizeof(HcfIvParamsSpec), 0)); + if (ivParamsSpec == nullptr) { + LOGE("ivParamsSpec malloc failed!"); + return HCF_INVALID_PARAMS; + } + ivParamsSpec->base.getType = GetIvParamsSpecType; + ivParamsSpec->iv = blob1; + HcfCryptoMode mode = HcfCryptoMode(opMode); + HcfParamsSpec *paramsSpec = reinterpret_cast(ivParamsSpec); + ivParamsSpec = nullptr; + HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); + HcfFree(paramsSpec); + paramsSpec = nullptr; + LOGD("[Cipher] FfiOHOSCipherInitByIv success"); + return res; + } + + int32_t FfiOHOSCipherInitByGcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec) + { + LOGD("[Cipher] FfiOHOSCipherInitByGcm start"); + if (key == nullptr) { + LOGE("[Cipher] key can not be nullptr."); + return HCF_INVALID_PARAMS; + } + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfGcmParamsSpec *gcmParamsSpec = reinterpret_cast( + HcfMalloc(sizeof(HcfGcmParamsSpec), 0)); + if (gcmParamsSpec == nullptr) { + LOGE("gcmParamsSpec malloc failed!"); + return HCF_INVALID_PARAMS; + } + HcfCryptoMode mode = HcfCryptoMode(opMode); + HcfBlob authTag = {}; + if (mode == DECRYPT_MODE) { + gcmParamsSpec->tag = spec.authTag; + } else if (mode == ENCRYPT_MODE) { + authTag.data = static_cast(HcfMalloc(GCM_AUTH_TAG_LEN, 0)); + if (authTag.data == nullptr) { + HcfFree(gcmParamsSpec); + return HCF_INVALID_PARAMS; + } + authTag.len = GCM_AUTH_TAG_LEN; + gcmParamsSpec->tag = authTag; + } + gcmParamsSpec->base.getType = GetGcmParamsSpecType; + gcmParamsSpec->iv = spec.iv; + gcmParamsSpec->aad = spec.add; + HcfParamsSpec *paramsSpec = reinterpret_cast(gcmParamsSpec); + gcmParamsSpec = nullptr; + HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); + HcfBlobDataFree(&authTag); + HcfFree(paramsSpec); + paramsSpec = nullptr; + LOGD("[Cipher] FfiOHOSCipherInitByGcm success"); + return res; + } + + int32_t FfiOHOSCipherInitByCcm(int64_t id, int32_t opMode, void* key, CParamsSpec spec) + { + LOGD("[Cipher] FfiOHOSCipherInitByCcm start"); + if (key == nullptr) { + LOGE("[Cipher] key can not be nullptr."); + return HCF_INVALID_PARAMS; + } + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfCcmParamsSpec *ccmParamsSpec = reinterpret_cast( + HcfMalloc(sizeof(HcfCcmParamsSpec), 0)); + if (ccmParamsSpec == nullptr) { + LOGE("ccmParamsSpec malloc failed!"); + return HCF_INVALID_PARAMS; + } + HcfBlob authTag = {}; + HcfCryptoMode mode = HcfCryptoMode(opMode); + if (mode == DECRYPT_MODE) { + ccmParamsSpec->tag = spec.authTag; + } else if (mode == ENCRYPT_MODE) { + authTag.data = static_cast(HcfMalloc(CCM_AUTH_TAG_LEN, 0)); + if (authTag.data == nullptr) { + HcfFree(ccmParamsSpec); + return HCF_INVALID_PARAMS; + } + authTag.len = CCM_AUTH_TAG_LEN; + ccmParamsSpec->tag = authTag; + } + ccmParamsSpec->base.getType = GetCcmParamsSpecType; + ccmParamsSpec->iv = spec.iv; + ccmParamsSpec->aad = spec.add; + HcfParamsSpec *paramsSpec = reinterpret_cast(ccmParamsSpec); + ccmParamsSpec = nullptr; + HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); + HcfBlobDataFree(&authTag); + HcfFree(paramsSpec); + paramsSpec = nullptr; + LOGD("[Cipher] FfiOHOSCipherInitByCcm success"); + return res; + } + + int32_t FfiOHOSCipherInitWithOutParams(int64_t id, int32_t opMode, void* key) + { + LOGD("[Cipher] FfiOHOSCipherInitWithOutParams start"); + if (key == nullptr) { + LOGE("[Cipher] key can not be nullptr."); + return HCF_INVALID_PARAMS; + } + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfParamsSpec *paramsSpec = nullptr; + HcfCryptoMode mode = HcfCryptoMode(opMode); + HcfResult res = instance->CipherInit(mode, static_cast(key), paramsSpec); + LOGD("[Cipher] FfiOHOSCipherInitWithOutParams success"); + return res; + } + + int32_t FfiOHOSCipherUpdate(int64_t id, HcfBlob *input, HcfBlob *output) + { + LOGD("[Cipher] CipherUpdate start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfResult res = instance->CipherUpdate(input, output); + LOGD("[Cipher] CipherUpdate success"); + return res; + } + + int32_t FfiOHOSCipherDoFinal(int64_t id, HcfBlob *input, HcfBlob *output) + { + LOGD("[Cipher] CipherDoFinal start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + HcfResult res = instance->CipherDoFinal(input, output); + LOGD("[Cipher] CipherDoFinal success %{public}d", res); + return res; + } + + int32_t FfiOHOSSetCipherSpec(int64_t id, int32_t item, HcfBlob pSource) + { + LOGD("[Cipher] SetCipherSpec start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + CipherSpecItem csi = CipherSpecItem(item); + HcfResult res = instance->SetCipherSpec(csi, pSource); + LOGD("[Cipher] SetCipherSpec success"); + return res; + } + + int32_t FfiOHOSGetCipherSpecString(int64_t id, int32_t item, char *returnString) + { + LOGD("[Cipher] GetCipherSpecString start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + CipherSpecItem csi = CipherSpecItem(item); + HcfResult res = instance->GetCipherSpecString(csi, returnString); + LOGD("[Cipher] GetCipherSpecString success"); + return res; + } + + int32_t FfiOHOSGetCipherSpecUint8Array(int64_t id, int32_t item, HcfBlob *returnUint8Array) + { + LOGD("[Cipher] GetCipherSpecUint8Array start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Cipher] instance not exist."); + return HCF_ERR_MALLOC; + } + CipherSpecItem csi = CipherSpecItem(item); + HcfResult res = instance->GetCipherSpecUint8Array(csi, returnUint8Array); + LOGD("[Cipher] GetCipherSpecUint8Array success"); + return res; + } + + const char *FfiOHOSCipherGetAlgName(int64_t id, int32_t* errCode) + { + LOGD("[Cipher] GetAlgName start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[SymKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetAlgorithm(errCode); + LOGD("[Cipher] GetAlgName success"); + return res; + } + + //--------------------- mac + int64_t FFiOHOSCryptoMacConstructor(char* algName, int32_t* errCode) + { + LOGD("[Mac] CreateMac start"); + HcfMac *macObj = nullptr; + HcfResult res = HcfMacCreate(algName, &macObj); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("create c macObj failed."); + return 0; + } + auto native = FFIData::Create(macObj); + if (native == nullptr) { + LOGE("[Mac] CreateMac failed"); + HcfObjDestroy(macObj); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Mac] CreateMac success"); + return native->GetID(); + } + + int32_t FfiOHOSCryptoMacInit(int64_t id, int64_t symKeyId) + { + LOGD("[MAC] FfiOHOSCryptoMacInit start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[MAC] MacImpl instance not exist."); + return HCF_ERR_MALLOC; + } + + auto keyInstance = FFIData::GetData(symKeyId); + if (!instance) { + LOGE("[MAC] SymKeyImpl instance not exist."); + return HCF_ERR_MALLOC; + } + + HcfResult res = instance->MacInit(keyInstance->GetSymKey()); + if (res != HCF_SUCCESS) { + LOGE("[MAC] MacInit error %{public}d", res); + } else { + LOGD("[MAC] FfiOHOSCryptoMacInit success"); + } + + return res; + } + + int32_t FfiOHOSCryptoMacUpdate(int64_t id, HcfBlob *input) + { + LOGD("[Mac] FfiOHOSCryptoMacUpdate start"); + HcfResult res = HCF_ERR_MALLOC; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[Mac] instance not exist."); + return res; + } + res = instance->MacUpdate(input); + LOGD("[Mac] FfiOHOSCryptoMacUpdate success"); + return res; + } + + HcfBlob FfiOHOSCryptoMacDoFinal(int64_t id, int32_t* errCode) + { + LOGD("[Mac] FfiOHOSCryptoMacDoFinal start"); + auto instance = FFIData::GetData(id); + HcfBlob blob = { .data = nullptr, .len = 0}; + if (!instance) { + LOGE("[Mac] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return blob; + } + HcfResult res = instance->MacDoFinal(&blob); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("doFinal failed!"); + return blob; + } + LOGD("[Mac] FfiOHOSCryptoMacDoFinal success"); + return blob; + } + + uint32_t FfiOHOSCryptoGetMacLength(int64_t id) + { + LOGD("[Mac] FfiOHOSGCryptoGetMacLength start"); + auto instance = FFIData::GetData(id); + uint32_t res = 0; + if (!instance) { + LOGE("[Mac] instance not exist."); + return res; + } + res = instance->GetMacLength(); + LOGD("[Mac] FfiOHOSGCryptoGetMacLength success"); + return res; + } + + //--------------------- sign + int64_t FFiOHOSCryptoSignConstructor(char* algName, int32_t* errCode) + { + LOGD("[Sign] FFiOHOSCryptoSignConstructor start"); + HcfSign *signObj = nullptr; + HcfResult res = HcfSignCreate(algName, &signObj); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("[Sign] FFiOHOSCryptoSignConstructor create c signObj failed."); + return 0; + } + auto native = FFIData::Create(signObj); + if (native == nullptr) { + LOGE("[Sign] FFiOHOSCryptoSignConstructor create failed"); + HcfObjDestroy(signObj); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Sign] FFiOHOSCryptoSignConstructor success"); + return native->GetID(); + } + + int32_t FFiOHOSSignInit(int64_t sid, int64_t pid) + { + LOGD("[Sign] FFiOHOSSignInit start"); + auto sign = FFIData::GetData(sid); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + auto priKeyImpl = FFIData::GetData(pid); + if (priKeyImpl == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get priKeyImpl obj."); + return HCF_INVALID_PARAMS; + } + HcfPriKey *priKey = priKeyImpl->GetPriKey(); + if (priKey == nullptr) { + LOGE("[Sign] FFiOHOSSignInit failed to get priKey obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignInit success"); + return sign->Init(priKey); + } + + int32_t FFiOHOSSignUpdate(int64_t id, HcfBlob input) + { + LOGD("[Sign] FFiOHOSSignUpdate start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignUpdate failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignUpdate success"); + return sign->Update(&input); + } + + int32_t FFiOHOSSignSign(int64_t id, HcfBlob *input, HcfBlob *output) + { + LOGD("[Sign] FFiOHOSSignSign start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSign failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSign success"); + return sign->Sign(input, output); + } + + int32_t FFiOHOSSignSetSignSpecByNum(int64_t id, int32_t itemValue) + { + LOGD("[Sign] FFiOHOSSignSetSignSpecByNum start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSetSignSpecByNum failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSetSignSpecByNum success"); + return sign->SetSignSpecByNum(itemValue); + } + + int32_t FFiOHOSSignSetSignSpecByArr(int64_t id, HcfBlob itemValue) + { + LOGD("[Sign] FFiOHOSSignSetSignSpecByArr start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignSetSignSpecByArr failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignSetSignSpecByArr success"); + return sign->SetSignSpecByArr(itemValue); + } + + int32_t FFiOHOSSignGetSignSpecString(int64_t id, SignSpecItem item, char *itemValue) + { + LOGD("[Sign] FFiOHOSSignGetSignSpecString start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignGetSignSpecString failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignGetSignSpecString success"); + return sign->GetSignSpecString(item, itemValue); + } + + int32_t FFiOHOSSignGetSignSpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) + { + LOGD("[Sign] FFiOHOSSignGetSignSpecNum start"); + auto sign = FFIData::GetData(id); + if (sign == nullptr) { + LOGE("[Sign] FFiOHOSSignGetSignSpecNum failed to get sign obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Sign] FFiOHOSSignGetSignSpecNum success"); + return sign->GetSignSpecNum(item, itemValue); + } + + //--------------------- verify + int64_t FFiOHOSVerifyConstructor(char* algName, int32_t* errCode) + { + LOGD("[Verify]FFiOHOSVerifyConstructor start"); + HcfVerify *verify = nullptr; + HcfResult res = HcfVerifyCreate(algName, &verify); + *errCode = static_cast(res); + if (res != HCF_SUCCESS) { + LOGE("[Verify] FFiOHOSVerifyConstructor create c verifyObj failed."); + return 0; + } + auto native = FFIData::Create(verify); + if (native == nullptr) { + LOGE("[Verify] FFiOHOSVerifyConstructor create failed"); + HcfObjDestroy(verify); + *errCode = HCF_ERR_MALLOC; + return 0; + } + LOGD("[Verify] FFiOHOSVerifyConstructor success"); + return native->GetID(); + } + + int32_t FFiOHOSVerifyInit(int64_t sid, int64_t pid) + { + LOGD("[Verify] FFiOHOSVerifyInit start"); + auto verify = FFIData::GetData(sid); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + auto pubKeyImpl = FFIData::GetData(pid); + if (pubKeyImpl == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get priKeyImpl obj."); + return HCF_INVALID_PARAMS; + } + HcfPubKey *pubKey = pubKeyImpl->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[Verify] FFiOHOSVerifyInit failed to get priKey obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyInit success"); + return verify->Init(pubKey); + } + + int32_t FFiOHOSVerifyUpdate(int64_t id, HcfBlob input) + { + LOGD("[Verify] FFiOHOSVerifyUpdate start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyUpdate failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyUpdate success"); + return verify->Update(&input); + } + + bool FFiOHOSVerifyVerify(int64_t id, HcfBlob *data, HcfBlob signatureData, int32_t* errCode) + { + LOGD("[Verify] FFiOHOSVerifyVerify start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyVerify success"); + return verify->Verify(data, signatureData, errCode); + } + + int32_t FFiOHOSVerifyRecover(int64_t id, HcfBlob input, HcfBlob *output) + { + LOGD("[Verify] FFiOHOSVerifyRecover start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyVerify failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyRecover success"); + return verify->Recover(input, output); + } + + + int32_t FFiOHOSVerifySetVerifySpecByNum(int64_t id, int32_t itemValue) + { + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifySetVerifySpecByNum failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByNum success"); + return verify->SetVerifySpecByNum(itemValue); + } + + int32_t FFiOHOSVerifySetVerifySpecByArr(int64_t id, HcfBlob itemValue) + { + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifySetVerifySpecByArr failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifySetVerifySpecByArr success"); + return verify->SetVerifySpecByArr(itemValue); + } + + int32_t FFiOHOSVerifyGetVerifySpecString(int64_t id, SignSpecItem item, char *itemValue) + { + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyGetVerifySpecString failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecString success"); + return verify->GetVerifySpecString(item, itemValue); + } + + int32_t FFiOHOSVerifyGetVerifySpecNum(int64_t id, SignSpecItem item, int32_t *itemValue) + { + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum start"); + auto verify = FFIData::GetData(id); + if (verify == nullptr) { + LOGE("[Verify] FFiOHOSVerifyGetVerifySpecNum failed to get verify obj."); + return HCF_INVALID_PARAMS; + } + LOGD("[Verify] FFiOHOSVerifyGetVerifySpecNum success"); + return verify->GetVerifySpecNum(item, itemValue); + } + + //--------------------- asykeygenerator + int64_t FFiOHOSAsyKeyGeneratorConstructor(char *algName, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor start"); + HcfAsyKeyGenerator *generator = nullptr; + *errCode = HcfAsyKeyGeneratorCreate(algName, &generator); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c generator fail."); + return 0; + } + auto instance = FFIData::Create(generator); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(generator); + LOGE("new asy key generator failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGeneratorConstructor end"); + return instance->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorGenerateKeyPair(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->generateKeyPair(generator, params, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("generate key pair fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyGenerateKeyPair end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorConvertKey(int64_t id, HcfBlob *pubKey, HcfBlob *priKey, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->convertKey(generator, params, pubKey, priKey, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("convert key fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertKey end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorConvertPemKey(int64_t id, char *pubKey, char *priKey, int32_t *errCode) + { + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGenerator *generator = instance->GetAsyKeyGenerator(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + HcfParamsSpec *params = nullptr; + *errCode = generator->convertPemKey(generator, params, pubKey, priKey, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGE("ConvertPemKey fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGenerator] FFiOHOSAsyKeyConvertPemKey end"); + return keyPair->GetID(); + } + + //--------------------- asykeyspecgenerator + int64_t AsyKeyGeneratorBySpecConstructor(HcfAsyKeyParamsSpec *asyKeySpec, int32_t *errCode) + { + HcfAsyKeyGeneratorBySpec *generator = nullptr; + *errCode = HcfAsyKeyGeneratorBySpecCreate(asyKeySpec, &generator); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create C generator by sepc fail."); + return 0; + } + auto instance = FFIData::Create(generator); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(generator); + LOGE("new asy key generator by spec failed!"); + return 0; + } + return instance->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaCommonSpec(HcfDsaCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDsaKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccCommonSpec(HcfEccCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccPriKeySpec(HcfEccPriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccPubKeySpec(HcfEccPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByEccKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByRsaKeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519PubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec(HcfAlg25519KeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByAlg25519KeyPairSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhPriKeySpec(HcfDhPriKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPriKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhPubKeySpec(HcfDhPubKeyParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhPubKeySpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorByDhKeyPairSpecc end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorByDhCommonSpec(HcfDhCommParamsSpec *spec, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec start"); + HcfAsyKeyParamsSpec *asyKeySpec = reinterpret_cast(spec); + int64_t id = AsyKeyGeneratorBySpecConstructor(asyKeySpec, errCode); + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBytDhCommonSpec end"); + return id; + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfKeyPair *returnKeyPair = nullptr; + *errCode = generator->generateKeyPair(generator, &returnKeyPair); + if (*errCode != HCF_SUCCESS) { + LOGD("generate key pair fail."); + return 0; + } + auto keyPair = FFIData::Create(returnKeyPair); + if (keyPair == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnKeyPair); + LOGE("new key pair failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGenerateKeyPair end"); + return keyPair->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfPriKey *returnPriKey = nullptr; + *errCode = generator->generatePriKey(generator, &returnPriKey); + if (*errCode != HCF_SUCCESS) { + LOGD("generate PriKey fail."); + return 0; + } + auto priKey = FFIData::Create(returnPriKey); + if (priKey == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnPriKey); + LOGE("new pri key failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePriKey end"); + return priKey->GetID(); + } + + int64_t FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey(int64_t id, int32_t *errCode) + { + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfAsyKeyGeneratorBySpec *generator = instance->GetAsyKeyGeneratorBySpec(); + if (generator == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build generator fail."); + return 0; + } + HcfPubKey *returnPubKey = nullptr; + *errCode = generator->generatePubKey(generator, &returnPubKey); + if (*errCode != HCF_SUCCESS) { + LOGD("generate PubKey fail."); + return 0; + } + auto pubKey = FFIData::Create(returnPubKey); + if (pubKey == nullptr) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(returnPubKey); + LOGE("new pub key failed"); + return 0; + } + LOGD("[AsyKeyGeneratorBySpec] FFiOHOSAsyKeyGeneratorBySpecGeneratePubKey end"); + return pubKey->GetID(); + } + + //--------------------- prikey + HcfBlob FFiOHOSPriKeyGetEncoded(int64_t id, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncoded start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncoded failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->base.getEncoded(&priKey->base, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncoded end"); + return ret; + } + + HcfBlob FFiOHOSPriKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedDer failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->getEncodedDer(priKey, format, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedDer end"); + return ret; + } + + char *FFiOHOSPriKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem start"); + char *ret = nullptr; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetEncodedPem failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = priKey->base.getEncodedPem(&priKey->base, format, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetEncodedPem end"); + return ret; + } + + int32_t FFiOHOSPriKeyClearMem(int64_t id) + { + LOGD("[PriKey] FFiOHOSPriKeyClearMem start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to unwrap private key obj!"); + return HCF_INVALID_PARAMS; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyClearMem failed to get private key obj!"); + return HCF_INVALID_PARAMS; + } + priKey->clearMem(priKey); + LOGD("[PriKey] FFiOHOSPriKeyClearMem end"); + return HCF_SUCCESS; + } + + int FFiOHOSPriKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + int ret = 0; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecInt(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + char *FFiOHOSPriKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + char *ret = nullptr; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecString(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + HcfBigInteger FFiOHOSPriKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + HcfBigInteger ret = { 0 }; + if (!instance) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to unwrap private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPriKey *priKey = instance->GetPriKey(); + if (priKey == nullptr) { + LOGE("[PriKey] FFiOHOSPriKeyGetAsyKeySpec failed to get private key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = priKey->getAsyKeySpecBigInteger(priKey, item, &ret); + LOGD("[PriKey] FFiOHOSPriKeyGetAsyKeySpec end"); + return ret; + } + + const char *FfiOHOSPriKeyGetFormat(int64_t id, int32_t* errCode) + { + LOGD("[PriKey] GetFormat start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PriKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetFormat(errCode); + LOGD("[PriKey] GetFormat success"); + return res; + } + + //--------------------- pubkey + HcfBlob FFiOHOSPubKeyGetEncoded(int64_t id, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncoded start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncoded failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->base.getEncoded(&pubKey->base, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncoded end"); + return ret; + } + + HcfBlob FFiOHOSPubKeyGetEncodedDer(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer start"); + HcfBlob ret = { .data = nullptr, .len = 0 }; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedDer failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->getEncodedDer(pubKey, format, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedDer end"); + return ret; + } + + char *FFiOHOSPubKeyGetEncodedPem(int64_t id, char *format, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem start"); + char *ret = nullptr; + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetEncodedPem failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + *errCode = pubKey->base.getEncodedPem(&pubKey->base, format, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetEncodedPem end"); + return ret; + } + + int FFiOHOSPubKeyGetAsyKeySpecByNum(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + int ret = 0; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecInt(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + char *FFiOHOSPubKeyGetAsyKeySpecByStr(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + char *ret = nullptr; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecString(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + HcfBigInteger FFiOHOSPubKeyGetAsyKeySpecByBigInt(int64_t id, int32_t itemType, int32_t *errCode) + { + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec start"); + auto instance = FFIData::GetData(id); + HcfBigInteger ret = { 0 }; + if (!instance) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to unwrap public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + HcfPubKey *pubKey = instance->GetPubKey(); + if (pubKey == nullptr) { + LOGE("[PubKey] FFiOHOSPubKeyGetAsyKeySpec failed to get public key obj!"); + *errCode = HCF_INVALID_PARAMS; + return ret; + } + AsyKeySpecItem item = AsyKeySpecItem(itemType); + *errCode = pubKey->getAsyKeySpecBigInteger(pubKey, item, &ret); + LOGD("[PubKey] FFiOHOSPubKeyGetAsyKeySpec end"); + return ret; + } + + const char *FfiOHOSPubKeyGetFormat(int64_t id, int32_t* errCode) + { + LOGD("[PubKey] GetFormat start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] instance not exist."); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char* res = instance->GetFormat(errCode); + LOGD("[PubKey] GetFormat success"); + return res; + } + + // ------------------------------------keypair + int64_t FFiOHOSKeyPairPubKey(int64_t id, int32_t *errCode) + { + LOGD("[KeyPair] FFiOHOSKeyPairPubKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfKeyPair *keyPair = instance->GetHcfKeyPair(); + if (keyPair == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get keyPair fail."); + return 0; + } + HcfPubKey *pubKey = keyPair->pubKey; + if (pubKey == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get pubKey fail."); + return 0; + } + auto pub = FFIData::Create(pubKey); + if (pub == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("new pub key failed"); + return 0; + } + LOGD("[KeyPair] FFiOHOSKeyPairPubKey end"); + return pub->GetID(); + } + + int64_t FFiOHOSKeyPairPriKey(int64_t id, int32_t *errCode) + { + LOGD("[KeyPair] FFiOHOSKeyPairPriKey start"); + auto instance = FFIData::GetData(id); + if (!instance) { + *errCode = HCF_INVALID_PARAMS; + LOGE("build instance fail."); + return 0; + } + HcfKeyPair *keyPair = instance->GetHcfKeyPair(); + if (keyPair == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get keyPair fail."); + return 0; + } + HcfPriKey *priKey = keyPair->priKey; + if (priKey == nullptr) { + *errCode = HCF_INVALID_PARAMS; + LOGE("get priKey fail."); + return 0; + } + auto pri = FFIData::Create(priKey); + if (pri == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("new pri key failed"); + return 0; + } + LOGD("[KeyPair] FFiOHOSKeyPairPriKey end"); + return pri->GetID(); + } + + // ------------------------------------kdf + int64_t FFiOHOSKdfConstructor(char *algName, int32_t *errCode) + { + LOGD("[Kdf] FFiOHOSKdfConstructor start"); + HcfKdf *kdf = nullptr; + *errCode = HcfKdfCreate(algName, &kdf); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c kdf fail."); + return 0; + } + auto instance = FFIData::Create(kdf); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(kdf); + LOGE("new kdf failed!"); + return 0; + } + LOGD("[Kdf] FFiOHOSKdfConstructor end"); + return instance->GetID(); + } + + int32_t FFiOHOSKdfGenerateSecretByPB(int64_t id, HcfPBKDF2ParamsSpec *params) + { + LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] FiOHOSKdfGenerateSecretByPB failed to get kdf impl obj!"); + return HCF_INVALID_PARAMS; + } + HcfKdfParamsSpec *tmp = reinterpret_cast(params); + LOGD("[Kdf] FiOHOSKdfGenerateSecretByPB end"); + return instance->GenerateSecret(tmp); + } + + int32_t FFiOHOSKdfGenerateSecretByH(int64_t id, HcfHkdfParamsSpec *params) + { + LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH start"); + auto instance = FFIData::GetData(id); + if (!instance) { + LOGE("[PubKey] F FFiOHOSKdfGenerateSecretByH failed to get kdf impl obj!"); + return HCF_INVALID_PARAMS; + } + HcfKdfParamsSpec *tmp = reinterpret_cast(params); + LOGD("[Kdf] FFiOHOSKdfGenerateSecretByH end"); + return instance->GenerateSecret(tmp); + } + + // --------------------------ecc_key_util + HcfEccCommParamsSpec *FFiOHOSECCKeyUtilGenECCCommonParamsSpec(char *curveName, int32_t *errCode) + { + return ECCKeyUtilImpl::GenECCCommonParamsSpec(curveName, errCode); + } + + HcfPoint FFiOHOSECCKeyUtilConvertPoint(char *curveName, HcfBlob encodedPoint, int32_t *errCode) + { + return ECCKeyUtilImpl::ConvertPoint(curveName, encodedPoint, errCode); + } + + HcfBlob FFiOHOSECCKeyUtilGetEncodedPoint(char *curveName, HcfPoint point, char *format, int32_t *errCode) + { + return ECCKeyUtilImpl::GetEncodedPoint(curveName, point, format, errCode); + } + + // ---------------------------keyagreement + int64_t FFiOHOSKeyAgreementConstructor(char *algName, int32_t *errCode) + { + LOGD("[KeyAgreement] FFiOHOSKdfConstructor start"); + HcfKeyAgreement *keyAgreement = nullptr; + *errCode = HcfKeyAgreementCreate(algName, &keyAgreement); + if (*errCode != HCF_SUCCESS) { + *errCode = HCF_INVALID_PARAMS; + LOGE("create c keyAgreement fail."); + return 0; + } + auto instance = FFIData::Create(keyAgreement); + if (!instance) { + *errCode = HCF_ERR_MALLOC; + HcfObjDestroy(keyAgreement); + LOGE("new key agreement failed!"); + return 0; + } + LOGD("[KeyAgreement] FFiOHOSKdfConstructor end"); + return instance->GetID(); + } + + HcfBlob FFiOHOSKeyAgreementGenerateSecret(int64_t id, int64_t priId, int64_t pubId, int32_t *errCode) + { + LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret start"); + auto instance = FFIData::GetData(id); + HcfBlob blob = { 0 }; + if (!instance) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get key agreement obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + auto priKey = FFIData::GetData(priId); + if (!priKey) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + auto pubKey = FFIData::GetData(pubId); + if (!pubKey) { + LOGE("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret failed to get priKey obj!"); + *errCode = HCF_INVALID_PARAMS; + return blob; + } + LOGD("[KeyAgreement] FFiOHOSKeyAgreementGenerateSecret end"); + return instance->GenerateSecret(priKey->GetPriKey(), pubKey->GetPubKey(), errCode); + } + + // dh_key_util + HcfDhCommParamsSpec *FFiOHOSDHKeyUtilGenDHCommonParamsSpec(int32_t pLen, int32_t skLen, int32_t *errCode) + { + return DHKeyUtilImpl::GenDHCommonParamsSpec(pLen, skLen, errCode); + } + + // sm2_crypto_util + HcfBlob FFiOHOSSm2CryptoUtilGenCipherTextBySpec(Sm2CipherTextSpec spec, char *mode, int32_t *errCode) + { + return Sm2CryptoUtilImpl::GenCipherTextBySpec(spec, mode, errCode); + } + + Sm2CipherTextSpec *FFiOHOSSm2CryptoUtilGetCipherTextSpec(HcfBlob input, char *mode, int32_t *errCode) + { + return Sm2CryptoUtilImpl::GetCipherTextSpec(input, mode, errCode); + } + } + } // namespace CryptoFramework } // namespace OHOS \ No newline at end of file diff --git a/frameworks/cj/src/crypto_mock.cpp b/frameworks/cj/src/crypto_mock.cpp index 65f9a07..37233e1 100644 --- a/frameworks/cj/src/crypto_mock.cpp +++ b/frameworks/cj/src/crypto_mock.cpp @@ -1,53 +1,53 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "cj_common_ffi.h" - -extern "C" { -FFI_EXPORT int FfiOHOSCreateRandom = 0; -FFI_EXPORT int FfiOHOSRandomGetAlgName = 0; -FFI_EXPORT int FfiOHOSGenerateRandom = 0; -FFI_EXPORT int FfiOHOSSetSeed = 0; -FFI_EXPORT int FfiOHOSCreateMd = 0; -FFI_EXPORT int FfiOHOSMdUpdate = 0; -FFI_EXPORT int FfiOHOSDigest = 0; -FFI_EXPORT int FfiOHOSGetMdLength = 0; -FFI_EXPORT int FfiOHOSCreateSymKeyGenerator = 0; -FFI_EXPORT int FfiOHOSSymKeyGeneratorGetAlgName = 0; -FFI_EXPORT int FfiOHOSGenerateSymKey = 0; -FFI_EXPORT int FfiOHOSConvertKey = 0; -FFI_EXPORT int FfiOHOSSymKeyGetAlgName = 0; -FFI_EXPORT int FfiOHOSSymKeyGetFormat = 0; -FFI_EXPORT int FfiOHOSSymKeyGetEncoded = 0; -FFI_EXPORT int FfiOHOSClearMem = 0; -FFI_EXPORT int FfiOHOSSymKeyGetHcfKey = 0; -FFI_EXPORT int FfiOHOSCreateCipher = 0; -FFI_EXPORT int FfiOHOSCipherInitByIv = 0; -FFI_EXPORT int FfiOHOSCipherInitByGcm = 0; -FFI_EXPORT int FfiOHOSCipherInitByCcm = 0; -FFI_EXPORT int FfiOHOSCipherInitWithOutParams = 0; -FFI_EXPORT int FfiOHOSCipherUpdate = 0; -FFI_EXPORT int FfiOHOSCipherDoFinal = 0; -FFI_EXPORT int FfiOHOSSetCipherSpec = 0; -FFI_EXPORT int FfiOHOSGetCipherSpecString = 0; -FFI_EXPORT int FfiOHOSGetCipherSpecUint8Array = 0; -FFI_EXPORT int FfiOHOSCipherGetAlgName = 0; -FFI_EXPORT int FFiOHOSCryptoMacConstructor = 0; -FFI_EXPORT int FfiOHOSCryptoMacInit = 0; -FFI_EXPORT int FfiOHOSCryptoMacUpdate = 0; -FFI_EXPORT int FfiOHOSCryptoMacDoFinal = 0; -FFI_EXPORT int FfiOHOSGCryptoGetMacLength = 0; -FFI_EXPORT int FFiOHOSCryptoSignConstructor = 0; +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cj_common_ffi.h" + +extern "C" { +FFI_EXPORT int FfiOHOSCreateRandom = 0; +FFI_EXPORT int FfiOHOSRandomGetAlgName = 0; +FFI_EXPORT int FfiOHOSGenerateRandom = 0; +FFI_EXPORT int FfiOHOSSetSeed = 0; +FFI_EXPORT int FfiOHOSCreateMd = 0; +FFI_EXPORT int FfiOHOSMdUpdate = 0; +FFI_EXPORT int FfiOHOSDigest = 0; +FFI_EXPORT int FfiOHOSGetMdLength = 0; +FFI_EXPORT int FfiOHOSCreateSymKeyGenerator = 0; +FFI_EXPORT int FfiOHOSSymKeyGeneratorGetAlgName = 0; +FFI_EXPORT int FfiOHOSGenerateSymKey = 0; +FFI_EXPORT int FfiOHOSConvertKey = 0; +FFI_EXPORT int FfiOHOSSymKeyGetAlgName = 0; +FFI_EXPORT int FfiOHOSSymKeyGetFormat = 0; +FFI_EXPORT int FfiOHOSSymKeyGetEncoded = 0; +FFI_EXPORT int FfiOHOSClearMem = 0; +FFI_EXPORT int FfiOHOSSymKeyGetHcfKey = 0; +FFI_EXPORT int FfiOHOSCreateCipher = 0; +FFI_EXPORT int FfiOHOSCipherInitByIv = 0; +FFI_EXPORT int FfiOHOSCipherInitByGcm = 0; +FFI_EXPORT int FfiOHOSCipherInitByCcm = 0; +FFI_EXPORT int FfiOHOSCipherInitWithOutParams = 0; +FFI_EXPORT int FfiOHOSCipherUpdate = 0; +FFI_EXPORT int FfiOHOSCipherDoFinal = 0; +FFI_EXPORT int FfiOHOSSetCipherSpec = 0; +FFI_EXPORT int FfiOHOSGetCipherSpecString = 0; +FFI_EXPORT int FfiOHOSGetCipherSpecUint8Array = 0; +FFI_EXPORT int FfiOHOSCipherGetAlgName = 0; +FFI_EXPORT int FFiOHOSCryptoMacConstructor = 0; +FFI_EXPORT int FfiOHOSCryptoMacInit = 0; +FFI_EXPORT int FfiOHOSCryptoMacUpdate = 0; +FFI_EXPORT int FfiOHOSCryptoMacDoFinal = 0; +FFI_EXPORT int FfiOHOSGCryptoGetMacLength = 0; +FFI_EXPORT int FFiOHOSCryptoSignConstructor = 0; } \ No newline at end of file diff --git a/frameworks/cj/src/key_impl.cpp b/frameworks/cj/src/key_impl.cpp index 20a8078..7a1f362 100644 --- a/frameworks/cj/src/key_impl.cpp +++ b/frameworks/cj/src/key_impl.cpp @@ -1,64 +1,65 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "key_impl.h" - -namespace OHOS { - namespace CryptoFramework { - KeyImpl::KeyImpl(HcfKey *hcfKey) - { - hcfKey_ = hcfKey; - } - - KeyImpl::~KeyImpl() {} - - HcfKey *KeyImpl::GetHcfKey() const - { - return hcfKey_; - } - - const char *KeyImpl::GetFormat(int32_t* errCode) - { - if (hcfKey_ == nullptr) { - LOGE("fail to get key obj!"); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char *format = hcfKey_->getFormat(hcfKey_); - *errCode = HCF_SUCCESS; - return format; - } - - const char *KeyImpl::GetAlgorithm(int32_t* errCode) - { - if (hcfKey_ == nullptr) { - LOGE("fail to get key obj!"); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char *algo = hcfKey_->getAlgorithm(hcfKey_); - *errCode = HCF_SUCCESS; - return algo; - } - - HcfResult KeyImpl::GetEncoded(HcfBlob *returnBlob) - { - if (hcfKey_ == nullptr) { - LOGE("fail to get key obj!"); - return HCF_ERR_MALLOC; - } - return hcfKey_->getEncoded(hcfKey_, returnBlob); - } - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "key_impl.h" +#include "log.h" + +namespace OHOS { + namespace CryptoFramework { + KeyImpl::KeyImpl(HcfKey *hcfKey) + { + hcfKey_ = hcfKey; + } + + KeyImpl::~KeyImpl() {} + + HcfKey *KeyImpl::GetHcfKey() const + { + return hcfKey_; + } + + const char *KeyImpl::GetFormat(int32_t* errCode) + { + if (hcfKey_ == nullptr) { + LOGE("fail to get key obj!"); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char *format = hcfKey_->getFormat(hcfKey_); + *errCode = HCF_SUCCESS; + return format; + } + + const char *KeyImpl::GetAlgorithm(int32_t* errCode) + { + if (hcfKey_ == nullptr) { + LOGE("fail to get key obj!"); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char *algo = hcfKey_->getAlgorithm(hcfKey_); + *errCode = HCF_SUCCESS; + return algo; + } + + HcfResult KeyImpl::GetEncoded(HcfBlob *returnBlob) + { + if (hcfKey_ == nullptr) { + LOGE("fail to get key obj!"); + return HCF_ERR_MALLOC; + } + return hcfKey_->getEncoded(hcfKey_, returnBlob); + } + } } \ No newline at end of file diff --git a/frameworks/cj/src/mac_impl.cpp b/frameworks/cj/src/mac_impl.cpp index bcc04ef..eb27e3a 100644 --- a/frameworks/cj/src/mac_impl.cpp +++ b/frameworks/cj/src/mac_impl.cpp @@ -1,71 +1,71 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "mac_impl.h" - -namespace OHOS { - namespace CryptoFramework { - MacImpl::MacImpl(HcfMac *macObj) - { - macObj_ = macObj; - } - - MacImpl::~MacImpl() - { - HcfObjDestroy(this->macObj_); - } - - HcfResult MacImpl::MacInit(HcfSymKey *symKey) - { - if (macObj_ == nullptr) { - LOGE("fail to get mac obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = macObj_->init(macObj_, symKey); - return res; - } - - HcfResult MacImpl::MacUpdate(HcfBlob *input) - { - if (macObj_ == nullptr) { - LOGE("fail to get mac obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = macObj_->update(macObj_, input); - return res; - } - - HcfResult MacImpl::MacDoFinal(HcfBlob *output) - { - if (macObj_ == nullptr) { - LOGE("fail to get mac obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = macObj_->doFinal(macObj_, output); - return res; - } - - uint32_t MacImpl::GetMacLength() - { - if (macObj_ == nullptr) { - LOGE("fail to get mac obj!"); - return HCF_ERR_MALLOC; - } - uint32_t retLen = macObj_->getMacLength(macObj_); - return retLen; - } - - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mac_impl.h" + +namespace OHOS { + namespace CryptoFramework { + MacImpl::MacImpl(HcfMac *macObj) + { + macObj_ = macObj; + } + + MacImpl::~MacImpl() + { + HcfObjDestroy(this->macObj_); + } + + HcfResult MacImpl::MacInit(HcfSymKey *symKey) + { + if (macObj_ == nullptr) { + LOGE("fail to get mac obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = macObj_->init(macObj_, symKey); + return res; + } + + HcfResult MacImpl::MacUpdate(HcfBlob *input) + { + if (macObj_ == nullptr) { + LOGE("fail to get mac obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = macObj_->update(macObj_, input); + return res; + } + + HcfResult MacImpl::MacDoFinal(HcfBlob *output) + { + if (macObj_ == nullptr) { + LOGE("fail to get mac obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = macObj_->doFinal(macObj_, output); + return res; + } + + uint32_t MacImpl::GetMacLength() + { + if (macObj_ == nullptr) { + LOGE("fail to get mac obj!"); + return HCF_ERR_MALLOC; + } + uint32_t retLen = macObj_->getMacLength(macObj_); + return retLen; + } + + } } \ No newline at end of file diff --git a/frameworks/cj/src/md_impl.cpp b/frameworks/cj/src/md_impl.cpp index b823373..543a3b0 100644 --- a/frameworks/cj/src/md_impl.cpp +++ b/frameworks/cj/src/md_impl.cpp @@ -1,61 +1,61 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "md_impl.h" - -namespace OHOS { - namespace CryptoFramework { - MdImpl::MdImpl(HcfMd *mdObj) - { - mdObj_ = mdObj; - } - - HcfResult MdImpl::MdUpdate(HcfBlob *input) - { - if (mdObj_ == nullptr) { - LOGE("fail to get md obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = mdObj_->update(mdObj_, input); - return res; - } - - MdImpl::~MdImpl() - { - HcfObjDestroy(this->mdObj_); - } - - HcfResult MdImpl::MdDoFinal(HcfBlob *output) - { - if (mdObj_ == nullptr) { - LOGE("fail to get md obj!"); - return HCF_ERR_MALLOC; - } - HcfResult res = mdObj_->doFinal(mdObj_, output); - return res; - } - - uint32_t MdImpl::GetMdLength(int32_t* errCode) - { - if (mdObj_ == nullptr) { - LOGE("fail to get md obj!"); - *errCode = HCF_ERR_MALLOC; - return 0; - } - uint32_t retLen = mdObj_->getMdLength(mdObj_); - *errCode = HCF_SUCCESS; - return retLen; - } - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "md_impl.h" + +namespace OHOS { + namespace CryptoFramework { + MdImpl::MdImpl(HcfMd *mdObj) + { + mdObj_ = mdObj; + } + + HcfResult MdImpl::MdUpdate(HcfBlob *input) + { + if (mdObj_ == nullptr) { + LOGE("fail to get md obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = mdObj_->update(mdObj_, input); + return res; + } + + MdImpl::~MdImpl() + { + HcfObjDestroy(this->mdObj_); + } + + HcfResult MdImpl::MdDoFinal(HcfBlob *output) + { + if (mdObj_ == nullptr) { + LOGE("fail to get md obj!"); + return HCF_ERR_MALLOC; + } + HcfResult res = mdObj_->doFinal(mdObj_, output); + return res; + } + + uint32_t MdImpl::GetMdLength(int32_t* errCode) + { + if (mdObj_ == nullptr) { + LOGE("fail to get md obj!"); + *errCode = HCF_ERR_MALLOC; + return 0; + } + uint32_t retLen = mdObj_->getMdLength(mdObj_); + *errCode = HCF_SUCCESS; + return retLen; + } + } } \ No newline at end of file diff --git a/frameworks/cj/src/random_impl.cpp b/frameworks/cj/src/random_impl.cpp index 03bac70..c97b2ab 100644 --- a/frameworks/cj/src/random_impl.cpp +++ b/frameworks/cj/src/random_impl.cpp @@ -1,71 +1,71 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "random_impl.h" - -namespace OHOS { - namespace CryptoFramework { - RandomImpl::RandomImpl(HcfRand *randObj) - { - randObj_ = randObj; - } - - RandomImpl::~RandomImpl() - { - HcfObjDestroy(this->randObj_); - } - - const char* RandomImpl::GetAlgName(int32_t* errCode) - { - if (randObj_ == nullptr) { - LOGE("fail to get rand obj!"); - *errCode = HCF_ERR_MALLOC; - return nullptr; - } - const char *algoName = randObj_->getAlgoName(randObj_); - *errCode = HCF_SUCCESS; - return algoName; - } - - HcfBlob RandomImpl::GenerateRandom(int32_t numBytes, int32_t* errCode) - { - HcfBlob randBlob = { .data = nullptr, .len = 0}; - if (randObj_ == nullptr) { - *errCode = HCF_ERR_MALLOC; - LOGE("fail to get rand obj!"); - return randBlob; - } - HcfResult res = randObj_->generateRandom(randObj_, numBytes, &randBlob); - if (res != HCF_SUCCESS) { - LOGE("generateRandom failed!"); - } - *errCode = static_cast(res); - return randBlob; - } - - void RandomImpl::SetSeed(HcfBlob *seed, int32_t* errCode) - { - if (randObj_ == nullptr) { - *errCode = HCF_ERR_MALLOC; - LOGE("fail to get rand obj!"); - return; - } - HcfResult res = randObj_->setSeed(randObj_, seed); - if (res != HCF_SUCCESS) { - LOGE("set seed failed."); - } - *errCode = static_cast(res); - } - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "random_impl.h" + +namespace OHOS { + namespace CryptoFramework { + RandomImpl::RandomImpl(HcfRand *randObj) + { + randObj_ = randObj; + } + + RandomImpl::~RandomImpl() + { + HcfObjDestroy(this->randObj_); + } + + const char* RandomImpl::GetAlgName(int32_t* errCode) + { + if (randObj_ == nullptr) { + LOGE("fail to get rand obj!"); + *errCode = HCF_ERR_MALLOC; + return nullptr; + } + const char *algoName = randObj_->getAlgoName(randObj_); + *errCode = HCF_SUCCESS; + return algoName; + } + + HcfBlob RandomImpl::GenerateRandom(int32_t numBytes, int32_t* errCode) + { + HcfBlob randBlob = { .data = nullptr, .len = 0}; + if (randObj_ == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("fail to get rand obj!"); + return randBlob; + } + HcfResult res = randObj_->generateRandom(randObj_, numBytes, &randBlob); + if (res != HCF_SUCCESS) { + LOGE("generateRandom failed!"); + } + *errCode = static_cast(res); + return randBlob; + } + + void RandomImpl::SetSeed(HcfBlob *seed, int32_t* errCode) + { + if (randObj_ == nullptr) { + *errCode = HCF_ERR_MALLOC; + LOGE("fail to get rand obj!"); + return; + } + HcfResult res = randObj_->setSeed(randObj_, seed); + if (res != HCF_SUCCESS) { + LOGE("set seed failed."); + } + *errCode = static_cast(res); + } + } } \ No newline at end of file diff --git a/frameworks/cj/src/sign_impl.cpp b/frameworks/cj/src/sign_impl.cpp index 89a4fbd..b278502 100644 --- a/frameworks/cj/src/sign_impl.cpp +++ b/frameworks/cj/src/sign_impl.cpp @@ -1,86 +1,86 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "sign_impl.h" - -namespace OHOS { -namespace CryptoFramework { -SignImpl::SignImpl(HcfSign *signObj) -{ - signObj_ = signObj; -} - -SignImpl::~SignImpl() -{ - HcfObjDestroy(this->signObj_); -} - -HcfResult SignImpl::Init(HcfPriKey *priKey) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->init(signObj_, nullptr, priKey); -} - -HcfResult SignImpl::Update(HcfBlob *input) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->update(signObj_, input); -} - -HcfResult SignImpl::Sign(HcfBlob *input, HcfBlob *output) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->sign(signObj_, input, output); -} - -HcfResult SignImpl::SetSignSpecByNum(int32_t itemValue) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->setSignSpecInt(signObj_, PSS_SALT_LEN_INT, itemValue); -} - -HcfResult SignImpl::SetSignSpecByArr(HcfBlob itemValue) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->setSignSpecUint8Array(signObj_, SM2_USER_ID_UINT8ARR, itemValue); -} - -HcfResult SignImpl::GetSignSpecString(SignSpecItem item, char *itemValue) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->getSignSpecString(signObj_, item, &itemValue); -} - -HcfResult SignImpl::GetSignSpecNum(SignSpecItem item, int32_t *itemValue) -{ - if (this->signObj_ == nullptr) { - return HCF_INVALID_PARAMS; - } - return this->signObj_->getSignSpecInt(signObj_, item, itemValue); -} -} +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sign_impl.h" + +namespace OHOS { +namespace CryptoFramework { +SignImpl::SignImpl(HcfSign *signObj) +{ + signObj_ = signObj; +} + +SignImpl::~SignImpl() +{ + HcfObjDestroy(this->signObj_); +} + +HcfResult SignImpl::Init(HcfPriKey *priKey) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->init(signObj_, nullptr, priKey); +} + +HcfResult SignImpl::Update(HcfBlob *input) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->update(signObj_, input); +} + +HcfResult SignImpl::Sign(HcfBlob *input, HcfBlob *output) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->sign(signObj_, input, output); +} + +HcfResult SignImpl::SetSignSpecByNum(int32_t itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->setSignSpecInt(signObj_, PSS_SALT_LEN_INT, itemValue); +} + +HcfResult SignImpl::SetSignSpecByArr(HcfBlob itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->setSignSpecUint8Array(signObj_, SM2_USER_ID_UINT8ARR, itemValue); +} + +HcfResult SignImpl::GetSignSpecString(SignSpecItem item, char *itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->getSignSpecString(signObj_, item, &itemValue); +} + +HcfResult SignImpl::GetSignSpecNum(SignSpecItem item, int32_t *itemValue) +{ + if (this->signObj_ == nullptr) { + return HCF_INVALID_PARAMS; + } + return this->signObj_->getSignSpecInt(signObj_, item, itemValue); +} +} } \ No newline at end of file diff --git a/frameworks/cj/src/sym_key_impl.cpp b/frameworks/cj/src/sym_key_impl.cpp index 8990b92..d123309 100644 --- a/frameworks/cj/src/sym_key_impl.cpp +++ b/frameworks/cj/src/sym_key_impl.cpp @@ -1,40 +1,40 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "sym_key_impl.h" - -namespace OHOS { - namespace CryptoFramework { - SymKeyImpl::SymKeyImpl(HcfSymKey *symKey) : KeyImpl(reinterpret_cast(symKey)) {} - - SymKeyImpl::~SymKeyImpl() - { - HcfObjDestroy(this->hcfKey_); - this->hcfKey_ = nullptr; - } - - HcfSymKey *SymKeyImpl::GetSymKey() const - { - return reinterpret_cast(KeyImpl::GetHcfKey()); - } - - void SymKeyImpl::ClearMem() - { - HcfSymKey *key = GetSymKey(); - if (key != nullptr) { - key->clearMem(key); - } - } - } +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "sym_key_impl.h" + +namespace OHOS { + namespace CryptoFramework { + SymKeyImpl::SymKeyImpl(HcfSymKey *symKey) : KeyImpl(reinterpret_cast(symKey)) {} + + SymKeyImpl::~SymKeyImpl() + { + HcfObjDestroy(this->hcfKey_); + this->hcfKey_ = nullptr; + } + + HcfSymKey *SymKeyImpl::GetSymKey() const + { + return reinterpret_cast(KeyImpl::GetHcfKey()); + } + + void SymKeyImpl::ClearMem() + { + HcfSymKey *key = GetSymKey(); + if (key != nullptr) { + key->clearMem(key); + } + } + } } \ No newline at end of file -- Gitee From 7bfafafc86001462d27bf60efb44cd32827d7760 Mon Sep 17 00:00:00 2001 From: lcc Date: Tue, 24 Sep 2024 10:05:17 +0800 Subject: [PATCH 31/32] =?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: lcc --- frameworks/js/jsi/src/jsi_list.cpp | 4 ++-- frameworks/js/jsi/src/jsi_md.cpp | 10 +++++----- frameworks/js/jsi/src/jsi_rand.cpp | 6 +++--- frameworks/js/jsi/src/jsi_utils.cpp | 2 +- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/frameworks/js/jsi/src/jsi_list.cpp b/frameworks/js/jsi/src/jsi_list.cpp index eb3b1e1..35cc91e 100644 --- a/frameworks/js/jsi/src/jsi_list.cpp +++ b/frameworks/js/jsi/src/jsi_list.cpp @@ -69,7 +69,7 @@ void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr) } if ((obj->objAddr != 0) && (obj->objAddr == deleteAddr)) { LOS_ListDelete(&(obj->listNode)); - HcfObjDestroy(static_cast(deleteAddr)); + HcfObjDestroy(reinterpret_cast(deleteAddr)); obj->objAddr = 0; HcfFree(obj); obj = nullptr; @@ -87,7 +87,7 @@ void ListDestroy(LiteAlgType type) return; } LOS_ListDelete(&(obj->listNode)); - HcfObjDestroy(static_cast(obj->objAddr)); + HcfObjDestroy(reinterpret_cast(obj->objAddr)); HcfFree(obj); obj = nullptr; } diff --git a/frameworks/js/jsi/src/jsi_md.cpp b/frameworks/js/jsi/src/jsi_md.cpp index 226f447..08bf010 100644 --- a/frameworks/js/jsi/src/jsi_md.cpp +++ b/frameworks/js/jsi/src/jsi_md.cpp @@ -72,7 +72,7 @@ JSIValue CryptoFrameworkLiteModule::Update(const JSIValue thisVal, const JSIValu LOGE("Update args is null!"); return JSI::CreateUndefined(); } - HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); + HcfMd *mdObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("Update mdObj is null!!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); @@ -106,7 +106,7 @@ JSIValue CryptoFrameworkLiteModule::UpdateSync(const JSIValue thisVal, const JSI LOGE("UpdateSync args is null!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); } - HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); + HcfMd *mdObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("UpdateSync mdObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); @@ -134,7 +134,7 @@ JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValu LOGE("Digest args is err or mdObj nullptr!"); return JSI::CreateUndefined(); } - HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); + HcfMd *mdObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("Digest mdObj is null!!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); @@ -157,7 +157,7 @@ JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValu JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); + HcfMd *mdObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("DigestSync mdObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); @@ -179,7 +179,7 @@ JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSI JSIValue CryptoFrameworkLiteModule::GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfMd *mdObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); + HcfMd *mdObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "mdObj")); if (mdObj == nullptr) { LOGE("GetMdLength mdObj is null!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); diff --git a/frameworks/js/jsi/src/jsi_rand.cpp b/frameworks/js/jsi/src/jsi_rand.cpp index 8e6d82c..9cb57bb 100644 --- a/frameworks/js/jsi/src/jsi_rand.cpp +++ b/frameworks/js/jsi/src/jsi_rand.cpp @@ -63,7 +63,7 @@ JSIValue CryptoFrameworkLiteModule::GenerateRandom(const JSIValue thisVal, const return JSI::CreateUndefined(); } - HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); + HcfRand *randObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); if (randObj == nullptr) { LOGE("GenerateRandom randObj is null!"); CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); @@ -98,7 +98,7 @@ JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, c return ThrowErrorCodeResult(HCF_INVALID_PARAMS); } - HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); + HcfRand *randObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); if (randObj == nullptr) { LOGE("GenerateRandom randObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); @@ -124,7 +124,7 @@ JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, c JSIValue CryptoFrameworkLiteModule::SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) { - HcfRand *randObj = static_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); + HcfRand *randObj = reinterpret_cast((uint32_t)JSI::GetNumberProperty(thisVal, "randObj")); if (randObj == nullptr) { LOGE("SetSeed randObj is null!!"); return ThrowErrorCodeResult(HCF_INVALID_PARAMS); diff --git a/frameworks/js/jsi/src/jsi_utils.cpp b/frameworks/js/jsi/src/jsi_utils.cpp index e10d29e..3320f1d 100644 --- a/frameworks/js/jsi/src/jsi_utils.cpp +++ b/frameworks/js/jsi/src/jsi_utils.cpp @@ -46,7 +46,7 @@ HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob) ret = HCF_INVALID_PARAMS; break; } - blob->data = static_cast(HcfMalloc(arraySize, 0)); + blob->data = reinterpret_cast(HcfMalloc(arraySize, 0)); if (blob->data == nullptr) { ret = HCF_ERR_MALLOC; break; -- Gitee From 48f56cb6dd82674c5348a056e72ec04dce7dea38 Mon Sep 17 00:00:00 2001 From: hhhFun Date: Tue, 24 Sep 2024 09:31:26 +0800 Subject: [PATCH 32/32] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E8=8E=B7=E5=8F=96pem?= =?UTF-8?q?=E7=A7=81=E9=92=A5=E5=87=BA=E9=94=99=E6=97=B6=E6=A6=82=E7=8E=87?= =?UTF-8?q?=E5=8D=A1=E4=BD=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hhhFun --- plugin/openssl_plugin/common/src/openssl_common.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/plugin/openssl_plugin/common/src/openssl_common.c b/plugin/openssl_plugin/common/src/openssl_common.c index 512219e..3669142 100644 --- a/plugin/openssl_plugin/common/src/openssl_common.c +++ b/plugin/openssl_plugin/common/src/openssl_common.c @@ -572,6 +572,12 @@ HcfResult ConvertPubPemStrToKey(EVP_PKEY **pkey, const char *keyType, int select return HCF_SUCCESS; } +int PrivateKeyReadNullCb(char *buf, int size, int rwflag, void *userdata) +{ + LOGE("Failed to read private key from bio."); + return -1; +} + HcfResult ConvertPriPemStrToKey(const char *keyStr, EVP_PKEY **pkey, const char *keyType) { BIO *bio = OpensslBioNew(OpensslBioSMem()); @@ -588,7 +594,7 @@ HcfResult ConvertPriPemStrToKey(const char *keyStr, EVP_PKEY **pkey, const char return HCF_ERR_CRYPTO_OPERATION; } - EVP_PKEY *pkeyRet = OpensslPemReadBioPrivateKey(bio, pkey, NULL, NULL); + EVP_PKEY *pkeyRet = OpensslPemReadBioPrivateKey(bio, pkey, PrivateKeyReadNullCb, NULL); OpensslBioFreeAll(bio); if (pkeyRet == NULL) { LOGE("Failed to read private key from bio"); -- Gitee