diff --git a/plugin/openssl_plugin/common/inc/dh_openssl_common.h b/plugin/openssl_plugin/common/inc/dh_openssl_common.h
index 3839440ab9ff8742b2f1b61ac57e22df7948f1d5..90bb18e523ca96a9845f4f38b4d40ee75f3423f2 100644
--- a/plugin/openssl_plugin/common/inc/dh_openssl_common.h
+++ b/plugin/openssl_plugin/common/inc/dh_openssl_common.h
@@ -22,8 +22,14 @@
 #include "result.h"
 #include "utils.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 EVP_PKEY *NewEvpPkeyByDh(DH *dh, bool withDuplicate);
 char *GetNidNameByDhId(int32_t pLen);
 char *GetNidNameByDhPLen(int32_t pLen);
+#ifdef __cplusplus
+}
+#endif
 
 #endif
diff --git a/plugin/openssl_plugin/common/inc/ecc_openssl_common.h b/plugin/openssl_plugin/common/inc/ecc_openssl_common.h
index 6c722bc6711627703b95836b1123bc74cd697fc4..a096f9ab10a700e800b7bc8f99875a484171890e 100644
--- a/plugin/openssl_plugin/common/inc/ecc_openssl_common.h
+++ b/plugin/openssl_plugin/common/inc/ecc_openssl_common.h
@@ -20,6 +20,9 @@
 #include "openssl_class.h"
 #include "openssl_common.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 HcfResult NewEcKeyPair(int32_t curveId, EC_KEY **returnEcKey);
 void FreeCurveBigNum(BIGNUM *pStd, BIGNUM *bStd, BIGNUM *xStd, BIGNUM *yStd);
 HcfResult GenerateEcGroupWithParamsSpec(const HcfEccCommParamsSpec *ecParams, EC_GROUP **ecGroup);
@@ -32,4 +35,8 @@ HcfResult GetFieldSize(const EC_GROUP *group, int32_t *fieldSize);
 HcfResult GetFieldType(const HcfKey *self, const bool isPrivate, char **returnString);
 HcfResult GetPkSkBigInteger(const HcfKey *self, bool isPrivate,
     const AsyKeySpecItem item, HcfBigInteger *returnBigInteger);
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c
index a7da2fae1840934412ca86eefb7ab76aebe51948..ece03d160687ef2c8a1787a39a6f91bb4eb2d3fb 100644
--- a/plugin/openssl_plugin/common/src/openssl_adapter.c
+++ b/plugin/openssl_plugin/common/src/openssl_adapter.c
@@ -39,9 +39,7 @@ void OpensslBnClear(BIGNUM *a)
 
 void OpensslBnClearFree(BIGNUM *a)
 {
-    if (a != NULL) {
-        BN_clear_free(a);
-    }
+    BN_clear_free(a);
 }
 
 BIGNUM *OpensslBnNew(void)
@@ -51,9 +49,7 @@ BIGNUM *OpensslBnNew(void)
 
 void OpensslBnFree(BIGNUM *a)
 {
-    if (a != NULL) {
-        BN_free(a);
-    }
+    BN_free(a);
 }
 
 BIGNUM *OpensslBin2Bn(const unsigned char *s, int len, BIGNUM *ret)
@@ -83,9 +79,7 @@ BN_CTX *OpensslBnCtxNew(void)
 
 void OpensslBnCtxFree(BN_CTX *ctx)
 {
-    if (ctx != NULL) {
-        BN_CTX_free(ctx);
-    }
+    BN_CTX_free(ctx);
 }
 
 int OpensslBnNumBytes(const BIGNUM *a)
@@ -195,16 +189,12 @@ void OpensslEcKeySetEncFlags(EC_KEY *ecKey, unsigned int flags)
 
 void OpensslEcKeyFree(EC_KEY *key)
 {
-    if (key != NULL) {
-        EC_KEY_free(key);
-    }
+    EC_KEY_free(key);
 }
 
 void OpensslEcPointFree(EC_POINT *point)
 {
-    if (point != NULL) {
-        EC_POINT_free(point);
-    }
+    EC_POINT_free(point);
 }
 
 EC_GROUP *OpensslEcGroupNewCurveGfp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
@@ -214,9 +204,7 @@ EC_GROUP *OpensslEcGroupNewCurveGfp(const BIGNUM *p, const BIGNUM *a, const BIGN
 
 void OpensslEcGroupFree(EC_GROUP *group)
 {
-    if (group != NULL) {
-        EC_GROUP_free(group);
-    }
+    EC_GROUP_free(group);
 }
 
 EC_POINT *OpensslEcPointNew(const EC_GROUP *group)
@@ -315,9 +303,7 @@ EVP_MD_CTX *OpensslEvpMdCtxNew(void)
 
 void OpensslEvpMdCtxFree(EVP_MD_CTX *ctx)
 {
-    if (ctx != NULL) {
-        EVP_MD_CTX_free(ctx);
-    }
+    EVP_MD_CTX_free(ctx);
 }
 
 void OpensslEvpMdCtxSetPkeyCtx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
@@ -436,9 +422,7 @@ int OpensslEvpPkeySet1EcKey(EVP_PKEY *pkey, EC_KEY *key)
 
 void OpensslEvpPkeyFree(EVP_PKEY *pkey)
 {
-    if (pkey != NULL) {
-        EVP_PKEY_free(pkey);
-    }
+    EVP_PKEY_free(pkey);
 }
 
 EVP_PKEY_CTX *OpensslEvpPkeyCtxNew(EVP_PKEY *pkey, ENGINE *e)
@@ -463,9 +447,7 @@ int OpensslEvpPkeyDerive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
 
 void OpensslEvpPkeyCtxFree(EVP_PKEY_CTX *ctx)
 {
-    if (ctx != NULL) {
-        EVP_PKEY_CTX_free(ctx);
-    }
+    EVP_PKEY_CTX_free(ctx);
 }
 
 int OpensslEvpPkeyEncrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
@@ -598,9 +580,7 @@ DSA *OpensslDsaNew(void)
 
 void OpensslDsaFree(DSA *dsa)
 {
-    if (dsa != NULL) {
-        DSA_free(dsa);
-    }
+    DSA_free(dsa);
 }
 
 int OpensslDsaUpRef(DSA *dsa)
@@ -705,9 +685,7 @@ RSA *OpensslRsaNew(void)
 
 void OpensslRsaFree(RSA *rsa)
 {
-    if (rsa != NULL) {
-        RSA_free(rsa);
-    }
+    RSA_free(rsa);
 }
 
 int OpensslRsaGenerateMultiPrimeKey(RSA *rsa, int bits, int primes,
@@ -876,9 +854,7 @@ int OpensslBioRead(BIO *b, void *data, int dlen)
 
 void OpensslBioFreeAll(BIO *a)
 {
-    if (a != NULL) {
-        return BIO_free_all(a);
-    }
+    return BIO_free_all(a);
 }
 
 int OpensslRandPrivBytes(unsigned char *buf, int num)
@@ -958,9 +934,7 @@ size_t OpensslHmacSize(const HMAC_CTX *ctx)
 
 void OpensslHmacCtxFree(HMAC_CTX *ctx)
 {
-    if (ctx != NULL) {
-        HMAC_CTX_free(ctx);
-    }
+    HMAC_CTX_free(ctx);
 }
 
 HMAC_CTX *OpensslHmacCtxNew(void)
@@ -970,9 +944,7 @@ HMAC_CTX *OpensslHmacCtxNew(void)
 
 void OpensslEvpCipherCtxFree(EVP_CIPHER_CTX *ctx)
 {
-    if (ctx != NULL) {
-        EVP_CIPHER_CTX_free(ctx);
-    }
+    EVP_CIPHER_CTX_free(ctx);
 }
 
 const EVP_CIPHER *OpensslEvpAes128Ecb(void)
@@ -1271,9 +1243,7 @@ int OpensslDhComputeKeyPadded(unsigned char *key, const BIGNUM *pubKey, DH *dh)
 
 void OpensslDhFree(DH *dh)
 {
-    if (dh != NULL) {
-        return DH_free(dh);
-    }
+    return DH_free(dh);
 }
 
 int OpensslDhGenerateKey(DH *dh)
@@ -1363,16 +1333,12 @@ struct Sm2CipherTextSt *OpensslD2iSm2CipherText(const uint8_t *ciphertext, size_
 
 void OpensslSm2CipherTextFree(struct Sm2CipherTextSt *sm2Text)
 {
-    if (sm2Text != NULL) {
-        Sm2CipherText_free(sm2Text);
-    }
+    Sm2CipherText_free(sm2Text);
 }
 
 void OpensslAsn1OctetStringFree(ASN1_OCTET_STRING *field)
 {
-    if (field != NULL) {
-        ASN1_OCTET_STRING_free(field);
-    }
+    ASN1_OCTET_STRING_free(field);
 }
 
 ASN1_OCTET_STRING *OpensslAsn1OctetStringNew(void)
@@ -1418,9 +1384,7 @@ OSSL_PARAM_BLD *OpensslOsslParamBldNew(void)
 
 void OpensslOsslParamBldFree(OSSL_PARAM_BLD *bld)
 {
-    if (bld != NULL) {
-        OSSL_PARAM_BLD_free(bld);
-    }
+    OSSL_PARAM_BLD_free(bld);
 }
 
 OSSL_PARAM *OpensslOsslParamBldToParam(OSSL_PARAM_BLD *bld)
@@ -1460,9 +1424,7 @@ EC_KEY *OpensslEvpPkeyGet1EcKey(EVP_PKEY *pkey)
 
 void OpensslOsslParamFree(OSSL_PARAM *params)
 {
-    if (params != NULL) {
-        OSSL_PARAM_free(params);
-    }
+    OSSL_PARAM_free(params);
 }
 
 int OpensslEcOct2Point(const EC_GROUP *group, EC_POINT *p, const unsigned char *buf, size_t len, BN_CTX *ctx)
diff --git a/test/unittest/src/aes_cipher/crypto_aes_cipher_test.cpp b/test/unittest/src/aes_cipher/crypto_aes_cipher_test.cpp
index 015b589dbf01fa2f5ea40564f2afb4f6f496f4f8..07d80f2ef0af88b0300e8d6cdacef0a7b89de665 100644
--- a/test/unittest/src/aes_cipher/crypto_aes_cipher_test.cpp
+++ b/test/unittest/src/aes_cipher/crypto_aes_cipher_test.cpp
@@ -818,6 +818,40 @@ HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0)
         LOGE("HcfCipherAesGeneratorSpiCreate failed!");
     }
     EXPECT_NE(ret, 0);
+
+    HcfCipherGeneratorSpi *cipher = nullptr;
+    CipherAttr params = {
+        .algo = HCF_ALG_AES,
+        .mode = HCF_ALG_MODE_ECB,
+        .paddingMode = HCF_ALG_PADDING_PKCS5,
+    };
+    ret = HcfCipherAesGeneratorSpiCreate(&params, &cipher);
+    EXPECT_EQ(ret, HCF_SUCCESS);
+
+    ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->update(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->doFinal(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfBlob dataArray = { .data = nullptr, .len = 0 };
+    ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
+    ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    (void)cipher->base.destroy(nullptr);
+
+    HcfObjDestroy(cipher);
+    HcfBlobDataFree(&dataArray);
 }
 
 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0)
diff --git a/test/unittest/src/crypto_3des_cipher_test.cpp b/test/unittest/src/crypto_3des_cipher_test.cpp
index f8a3ee8f7f286972a036337d5081430fad6c1686..e2a51d56d005b6fa9ea20c85433aa547fb237c6d 100644
--- a/test/unittest/src/crypto_3des_cipher_test.cpp
+++ b/test/unittest/src/crypto_3des_cipher_test.cpp
@@ -1803,10 +1803,44 @@ clearup:
 
 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest035, TestSize.Level0)
 {
-    int ret = HcfCipherDesGeneratorSpiCreate(nullptr, nullptr);
+    HcfResult ret = HcfCipherDesGeneratorSpiCreate(nullptr, nullptr);
     if (ret != 0) {
         LOGE("HcfCipherDesGeneratorSpiCreate failed!");
     }
     EXPECT_NE(ret, 0);
+
+    HcfCipherGeneratorSpi *cipher = nullptr;
+    CipherAttr params = {
+        .algo = HCF_ALG_DES,
+        .mode = HCF_ALG_MODE_ECB,
+        .paddingMode = HCF_ALG_PADDING_PKCS5,
+    };
+    ret = HcfCipherDesGeneratorSpiCreate(&params, &cipher);
+    EXPECT_EQ(ret, HCF_SUCCESS);
+
+    ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->update(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->doFinal(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfBlob dataArray = { .data = nullptr, .len = 0 };
+    ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
+    ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    (void)cipher->base.destroy(nullptr);
+
+    HcfObjDestroy(cipher);
+    HcfBlobDataFree(&dataArray);
 }
 }
diff --git a/test/unittest/src/crypto_dh_key_agreement_test.cpp b/test/unittest/src/crypto_dh_key_agreement_test.cpp
index 55c854779b2a9caa0aeafc3d049b77f1a053349f..76aeaf7821f04a2b593f4bee0b1bb26b25f1c768 100644
--- a/test/unittest/src/crypto_dh_key_agreement_test.cpp
+++ b/test/unittest/src/crypto_dh_key_agreement_test.cpp
@@ -14,6 +14,8 @@
  */
 
 #include <gtest/gtest.h>
+#include <openssl/dh.h>
+#include <openssl/evp.h>
 #include "securec.h"
 
 #include "asy_key_generator.h"
@@ -29,6 +31,8 @@
 #include "memory.h"
 #include "memory_mock.h"
 #include "openssl_adapter_mock.h"
+#include "dh_openssl_common.h"
+#include "openssl_class.h"
 
 using namespace std;
 using namespace testing::ext;
@@ -387,6 +391,8 @@ HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest010, TestSize.Level0)
     res = spiObj->engineGenerateSecret(spiObj, dh1536KeyPair_->priKey, (HcfPubKey *)&g_obj, &out);
     ASSERT_EQ(res, HCF_INVALID_PARAMS);
 
+    EVP_PKEY *pubPKey = NewEvpPkeyByDh(((HcfOpensslDhPubKey *)dh1536KeyPair_->pubKey)->pk, false);
+    EXPECT_EQ(pubPKey, NULL);
     HcfFree(out.data);
     HcfObjDestroy(spiObj);
 }
@@ -704,4 +710,11 @@ HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest021, TestSize.Level0)
     HcfObjDestroy(dh512KeyPair);
     HcfObjDestroy(dh512KeyPair1);
 }
+
+HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHCommonTest01, TestSize.Level0)
+{
+    int32_t id = -1;
+    EXPECT_EQ(GetNidNameByDhId(id), nullptr);
+    EXPECT_EQ(GetNidNameByDhPLen(id), nullptr);
+}
 }
diff --git a/test/unittest/src/crypto_ecc_key_agreement_test.cpp b/test/unittest/src/crypto_ecc_key_agreement_test.cpp
index 5f9a8e15698faa6dbf1ba22dac1027a1798c1b67..809c50bdf4a422df2d72a83d6a365e7c0ef08a62 100644
--- a/test/unittest/src/crypto_ecc_key_agreement_test.cpp
+++ b/test/unittest/src/crypto_ecc_key_agreement_test.cpp
@@ -722,4 +722,10 @@ HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest402, TestSize.Level
     }
     EndRecordOpensslCallNum();
 }
+
+HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccCommonTest01, TestSize.Level0)
+{
+    HcfResult ret = GenerateEcGroupWithParamsSpec(nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+}
 }
diff --git a/test/unittest/src/crypto_hkdf_test.cpp b/test/unittest/src/crypto_hkdf_test.cpp
index f6027dcaa6813bd71dcd67604770dd20629ce17b..281420d70ec17ebfe75be9757213ba7e662f4910 100644
--- a/test/unittest/src/crypto_hkdf_test.cpp
+++ b/test/unittest/src/crypto_hkdf_test.cpp
@@ -601,5 +601,19 @@ HWTEST_F(CryptoHkdfTest, CryptoHkdfErr12, TestSize.Level0)
 {
     HcfResult ret = HcfKdfHkdfSpiCreate(nullptr, nullptr);
     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfKdfDeriveParams params = {};
+    params.algo = HCF_ALG_HKDF;
+    params.md = HCF_OPENSSL_DIGEST_SHA256;
+    params.mode = HCF_ALG_MODE_EXTRACT_AND_EXPAND;
+    
+    HcfKdfSpi *spiObj = nullptr;
+    ret = HcfKdfHkdfSpiCreate(&params, &spiObj);
+    EXPECT_EQ(ret, HCF_SUCCESS);
+
+    (void)spiObj->base.destroy(nullptr);
+    ret = spiObj->generateSecret(nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+    HcfObjDestroy(spiObj);
 }
 }
diff --git a/test/unittest/src/crypto_pbkdf2_test.cpp b/test/unittest/src/crypto_pbkdf2_test.cpp
index 77d93b5aba57a6073b6b5f87dfaee4028f4144ee..d1da9c35736be5db76851d46c90366aa65335396 100644
--- a/test/unittest/src/crypto_pbkdf2_test.cpp
+++ b/test/unittest/src/crypto_pbkdf2_test.cpp
@@ -496,5 +496,19 @@ HWTEST_F(CryptoPbkdf2Test, CryptoPbkdf2TestError13, TestSize.Level0)
 {
     HcfResult ret = HcfKdfPBKDF2SpiCreate(nullptr, nullptr);
     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfKdfDeriveParams params = {};
+    params.algo = HCF_ALG_PKBDF2;
+    params.md = HCF_OPENSSL_DIGEST_SHA256;
+    
+    HcfKdfSpi *spiObj = nullptr;
+    ret = HcfKdfPBKDF2SpiCreate(&params, &spiObj);
+    EXPECT_EQ(ret, HCF_SUCCESS);
+
+    (void)spiObj->base.destroy(nullptr);
+    ret = spiObj->generateSecret(nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfObjDestroy(spiObj);
 }
 }
diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp
index 34c41f999bc1880c77b7bb01922e99d7a396b19f..0919bfdd3891031859f09196be7a4d5a36479057 100644
--- a/test/unittest/src/crypto_rand_test.cpp
+++ b/test/unittest/src/crypto_rand_test.cpp
@@ -243,4 +243,22 @@ HWTEST_F(CryptoRandTest, InvalidSpiGetAlgTest001, TestSize.Level0)
 
     HcfObjDestroy(randObj);
 }
+
+HWTEST_F(CryptoRandTest, InvalidSpiTestGenerateRandom001, TestSize.Level0)
+{
+    HcfRandSpi *spiObj = nullptr;
+
+    HcfResult ret = HcfRandSpiCreate(&spiObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+
+    ret = spiObj->engineGenerateRandom(nullptr, 0, nullptr);
+    ASSERT_EQ(ret, HCF_INVALID_PARAMS);
+
+    struct HcfBlob randBlob = { .data = nullptr, .len = 0 };
+    ret = spiObj->engineGenerateRandom(spiObj, 0, &randBlob);
+    ASSERT_EQ(ret, HCF_INVALID_PARAMS);
+
+    (void)spiObj->engineGetAlgoName(nullptr);
+    HcfObjDestroy(spiObj);
+}
 }
\ No newline at end of file
diff --git a/test/unittest/src/crypto_sm4_cipher_test.cpp b/test/unittest/src/crypto_sm4_cipher_test.cpp
index 51a77518262420cbb818646c23eb7fd31c5f6c0d..f668c724f86b36296914d30e92e794e1ead88506 100644
--- a/test/unittest/src/crypto_sm4_cipher_test.cpp
+++ b/test/unittest/src/crypto_sm4_cipher_test.cpp
@@ -922,12 +922,44 @@ CLEAR_UP:
 
 HWTEST_F(CryptoSM4CipherTest, CryptoSm4CipherTest062, TestSize.Level0)
 {
-    HcfResult res = HCF_SUCCESS;
+    HcfResult ret = HCF_SUCCESS;
+
+    ret = HcfCipherSm4GeneratorSpiCreate(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+
     HcfCipherGeneratorSpi *cipher = nullptr;
+    CipherAttr params = {
+        .algo = HCF_ALG_SM4,
+        .mode = HCF_ALG_MODE_ECB,
+        .paddingMode = HCF_ALG_PADDING_PKCS5,
+    };
+    ret = HcfCipherSm4GeneratorSpiCreate(&params, &cipher);
+    EXPECT_EQ(ret, HCF_SUCCESS);
+
+    ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->update(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    ret = cipher->doFinal(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ret, HCF_INVALID_PARAMS);
+
+    HcfBlob dataArray = { .data = nullptr, .len = 0 };
+    ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
+    ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
+    EXPECT_EQ(ret, HCF_NOT_SUPPORT);
+
+    (void)cipher->base.destroy(nullptr);
 
-    res = HcfCipherSm4GeneratorSpiCreate(nullptr, &cipher);
-    EXPECT_NE(res, HCF_SUCCESS);
     HcfObjDestroy(cipher);
+    HcfBlobDataFree(&dataArray);
 }
 
 HWTEST_F(CryptoSM4CipherTest, CryptoSm4CipherTest063, TestSize.Level0)