diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp
index 700d8cecaa7ce38a0dcf9abd275c4346541eae35..3ef694e1705df573db720461b764a15c8d5fba38 100644
--- a/test/unittest/src/crypto_mac_test.cpp
+++ b/test/unittest/src/crypto_mac_test.cpp
@@ -593,6 +593,60 @@ HWTEST_F(CryptoMacTest, InvalidInputMacTest001, TestSize.Level0)
     EXPECT_NE(ret, HCF_SUCCESS);
 }
 
+HWTEST_F(CryptoMacTest, NullParamMacTest001, TestSize.Level0)
+{
+    HcfMac *macObj = nullptr;
+    HcfResult ret = HcfMacCreate("SHA256", &macObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    ret = macObj->init(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = macObj->update(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = macObj->doFinal(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    uint32_t len = macObj->getMacLength(nullptr);
+    EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
+    const char *algoName = macObj->getAlgoName(nullptr);
+    EXPECT_EQ(algoName, nullptr);
+    macObj->base.destroy(nullptr);
+    HcfObjDestroy(macObj);
+}
+
+HWTEST_F(CryptoMacTest, InvalidFrameworkClassMacTest001, TestSize.Level0)
+{
+    HcfMac *macObj = nullptr;
+    HcfResult ret = HcfMacCreate("SHA256", &macObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    HcfMac invalidMacObj = {{0}};
+    invalidMacObj.base.getClass = GetInvalidMacClass;
+    HcfSymKeyGenerator *generator = nullptr;
+    ret = HcfSymKeyGeneratorCreate("AES128", &generator);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    uint8_t testKey[] = "abcdefghijklmnop";
+    uint32_t testKeyLen = sizeof(testKey) / sizeof(testKey[0]);
+    HcfSymKey *key = nullptr;
+    HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
+    generator->convertSymKey(generator, &keyMaterialBlob, &key);
+    uint8_t testData[] = "My test data";
+    HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
+    HcfBlob outBlob = { .data = nullptr, .len = 0 };
+    ret = macObj->init(&invalidMacObj, key);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = macObj->update(&invalidMacObj, &inBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = macObj->doFinal(&invalidMacObj, &outBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    uint32_t len = macObj->getMacLength(&invalidMacObj);
+    EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
+    const char *algoName = macObj->getAlgoName(&invalidMacObj);
+    EXPECT_EQ(algoName, nullptr);
+    HcfBlobDataClearAndFree(&outBlob);
+    macObj->base.destroy(&(invalidMacObj.base));
+    HcfObjDestroy(macObj);
+    HcfObjDestroy(key);
+    HcfObjDestroy(generator);
+}
+
 HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0)
 {
     HcfMacSpi *spiObj = nullptr;
diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp
index fdc18d337aed329657c9c1c63d4e5cb9b0b8b9d8..e1b0a9e15dbf74c06e3493991fddcb12740091f3 100644
--- a/test/unittest/src/crypto_md_test.cpp
+++ b/test/unittest/src/crypto_md_test.cpp
@@ -381,6 +381,45 @@ HWTEST_F(CryptoMdTest, InvalidInputMdTest001, TestSize.Level0)
     EXPECT_NE(ret, HCF_SUCCESS);
 }
 
+HWTEST_F(CryptoMdTest, NullParamMdTest001, TestSize.Level0)
+{
+    HcfMd *mdObj = nullptr;
+    HcfResult ret = HcfMdCreate("MD5", &mdObj);
+    ret = mdObj->update(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = mdObj->doFinal(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    uint32_t len = mdObj->getMdLength(nullptr);
+    EXPECT_EQ(len, HCF_OPENSSL_INVALID_MD_LEN);
+    const char *algoName = mdObj->getAlgoName(nullptr);
+    EXPECT_EQ(algoName, nullptr);
+    mdObj->base.destroy(nullptr);
+    HcfObjDestroy(mdObj);
+}
+
+HWTEST_F(CryptoMdTest, InvalidFrameworkClassMdTest001, TestSize.Level0)
+{
+    HcfMd *mdObj = nullptr;
+    HcfResult ret = HcfMdCreate("SHA256", &mdObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    HcfMd invalidMdObj = {{0}};
+    invalidMdObj.base.getClass = GetInvalidMdClass;
+    uint8_t testData[] = "My test data";
+    HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
+    HcfBlob outBlob = { .data = nullptr, .len = 0 };
+    ret = mdObj->update(&invalidMdObj, &inBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = mdObj->doFinal(&invalidMdObj, &outBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    uint32_t len = mdObj->getMdLength(&invalidMdObj);
+    EXPECT_EQ(len, HCF_OPENSSL_INVALID_MD_LEN);
+    const char *algoName = mdObj->getAlgoName(&invalidMdObj);
+    EXPECT_EQ(algoName, nullptr);
+    HcfBlobDataClearAndFree(&outBlob);
+    mdObj->base.destroy(&(invalidMdObj.base));
+    HcfObjDestroy(mdObj);
+}
+
 HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0)
 {
     HcfMdSpi *spiObj = nullptr;
diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp
index ab1c99dfe63bf2f0ddeeccae4db5282935603b91..09a1546b7d53ef7024ac32c52e2f022c832f9da8 100644
--- a/test/unittest/src/crypto_rand_test.cpp
+++ b/test/unittest/src/crypto_rand_test.cpp
@@ -194,6 +194,37 @@ HWTEST_F(CryptoRandTest, NullInputRandTest001, TestSize.Level0)
     EXPECT_NE(ret, HCF_SUCCESS);
 }
 
+HWTEST_F(CryptoRandTest, NullParamRandTest001, TestSize.Level0)
+{
+    HcfRand *randObj = nullptr;
+    HcfResult ret = HcfRandCreate(&randObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    ret = randObj->generateRandom(nullptr, 0, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = randObj->setSeed(nullptr, nullptr);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    randObj->base.destroy(nullptr);
+    HcfObjDestroy(randObj);
+}
+
+HWTEST_F(CryptoRandTest, InvalidFrameworkClassRandTest001, TestSize.Level0)
+{
+    HcfRand *randObj = nullptr;
+    HcfResult ret = HcfRandCreate(&randObj);
+    ASSERT_EQ(ret, HCF_SUCCESS);
+    HcfRand invalidRandObj = {{0}};
+    invalidRandObj.base.getClass = GetInvalidRandClass;
+    int32_t randomLen = 32;
+    struct HcfBlob randomBlob = { .data = nullptr, .len = 0 };
+    ret = randObj->generateRandom(&invalidRandObj, randomLen, &randomBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    ret = randObj->setSeed(&invalidRandObj, &randomBlob);
+    EXPECT_NE(ret, HCF_SUCCESS);
+    HcfBlobDataClearAndFree(&randomBlob);
+    randObj->base.destroy(&(invalidRandObj.base));
+    HcfObjDestroy(randObj);
+}
+
 HWTEST_F(CryptoRandTest, InvalidSpiClassRandTest001, TestSize.Level0)
 {
     HcfRandSpi *spiObj = nullptr;