From b81d26f8fdab146e4228e44255b5b36349b942f5 Mon Sep 17 00:00:00 2001 From: quyawei Date: Fri, 11 Nov 2022 14:39:00 +0800 Subject: [PATCH 01/16] update TDD cases Signed-off-by: quyawei --- .../crypto_operation/hmac/src/mac_openssl.c | 9 +- .../crypto_operation/md/src/md_openssl.c | 7 +- plugin/openssl_plugin/rand/src/rand_openssl.c | 12 +-- test/unittest/src/crypto_mac_test.cpp | 101 +++++++++++++----- test/unittest/src/crypto_md_test.cpp | 84 ++++++++++----- test/unittest/src/crypto_rand_test.cpp | 43 +++++--- 6 files changed, 163 insertions(+), 93 deletions(-) diff --git a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c index 00abbbf..a63b601 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c @@ -125,12 +125,7 @@ static HcfResult OpensslEngineDoFinalMac(HcfMacSpi *self, HcfBlob *output) LOGE("Failed to allocate output->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(output->data, outputLen, outputBuf, outputLen) != EOK) { - LOGE("memcpy error!"); - HcfFree(output->data); - output->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); output->len = outputLen; return HCF_SUCCESS; } @@ -139,7 +134,7 @@ static uint32_t OpensslEngineGetMacLength(HcfMacSpi *self) { if (OpensslGetMacCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return HCF_ERR_CRYPTO_OPERATION; + return 0; } return HMAC_size(OpensslGetMacCtx(self)); } 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 fc8bae5..6e32acd 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -98,12 +98,7 @@ static HcfResult OpensslEngineDoFinalMd(HcfMdSpi *self, HcfBlob *output) LOGE("Failed to allocate output->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(output->data, outputLen, outputBuf, outputLen) != EOK) { - LOGE("memcpy error!"); - HcfFree(output->data); - output->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); output->len = outputLen; return HCF_SUCCESS; } diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index 08c7899..a1a05a2 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -46,12 +46,7 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl LOGE("Failed to allocate random->data memory!"); return HCF_ERR_MALLOC; } - if (memcpy_s(random->data, numBytes, rand_buf, numBytes) != EOK) { - LOGE("memcpy error!"); - HcfFree(random->data); - random->data = NULL; - return HCF_ERR_COPY; - } + (void)memcpy_s(random->data, numBytes, rand_buf, numBytes); random->len = numBytes; return HCF_SUCCESS; } @@ -60,10 +55,7 @@ static HcfResult OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { int32_t seedLen = seed->len; unsigned char seedBuf[seedLen]; - if (memcpy_s(seedBuf, seedLen, seed->data, seedLen) != EOK) { - LOGE("memcpy error!"); - return HCF_ERR_COPY; - } + (void)memcpy_s(seedBuf, seedLen, seed->data, seedLen); RAND_seed(seedBuf, seedLen); return HCF_SUCCESS; } diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index 74c39c9..90dadc9 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -19,6 +19,7 @@ #include "mac.h" #include "sym_key_generator.h" +#include "mac_openssl.h" #include "log.h" #include "memory.h" @@ -173,7 +174,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; // test api functions ret = macObj->update(macObj, &inBlob); EXPECT_NE(ret, 0); @@ -198,7 +199,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // define input and output data in blob form - HcfBlob *inBlob= nullptr; + HcfBlob *inBlob = nullptr; // test api functions ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -230,7 +231,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; // test api functions ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -249,8 +250,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) ret = (int32_t)HcfMacCreate("SHA1", &macObj); EXPECT_EQ(ret, 0); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob outBlob = {0}; // test api functions ret = macObj->doFinal(macObj, &outBlob); EXPECT_NE(ret, 0); @@ -277,8 +277,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); printf("get symkey finish"); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, (HcfSymKey *)key); @@ -321,10 +320,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -356,11 +354,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) HcfSymKey *key = nullptr; HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); - // set input and output buf - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; + HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -436,9 +432,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -475,9 +470,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[28] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -514,9 +508,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[32] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -553,9 +546,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[48] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -592,9 +584,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[64] = {0}; - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, (HcfSymKey *)key); EXPECT_EQ(ret, 0); @@ -610,4 +601,56 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) HcfObjDestroy(key); HcfObjDestroy(generator); } + +static const char *GetInvalidMacClass(void) +{ + return "INVALID_MAC_CLASS"; +} + +HWTEST_F(CryptoMacTest, InvalidInputMacTest001, TestSize.Level0) +{ + HcfResult ret = OpensslMacSpiCreate("SHA256", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); + HcfMacSpi *spiObj = nullptr; + ret = OpensslMacSpiCreate(nullptr, &spiObj); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) +{ + HcfMacSpi *spiObj = nullptr; + HcfMacSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidMacClass; + // create a symKey generator + HcfSymKeyGenerator *generator = nullptr; + HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS); + // set key data and convert it to key obj + uint8_t testKey[] = "abcdefghijklmnop"; + uint32_t testKeyLen = 16; + HcfSymKey *key = nullptr; + HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + generator->convertSymKey(generator, &keyMaterialBlob, &key); + // set input and output blob + uint8_t testData[] = "My test data"; + uint32_t testDataLen = 12; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; + ret = OpensslMacSpiCreate("SHA256", &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + ret = spiObj->engineInitMac(&invalidSpi, (HcfSymKey *)key); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = spiObj->engineGetMacLength(&invalidSpi); + EXPECT_EQ(len, 0); + HcfObjDestroy(spiObj); + HcfObjDestroy(key); + HcfObjDestroy(generator); +} } \ No newline at end of file diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index 25b8efe..a639104 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -17,6 +17,7 @@ #include "securec.h" #include "md.h" +#include "md_openssl.h" #include "log.h" #include "memory.h" @@ -135,7 +136,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest001, TestSize.Level0) ret = (int32_t)HcfMdCreate("SHA1", &mdObj); EXPECT_EQ(ret, 0); // define input and output data in blob form - HcfBlob *inBlob= nullptr; + HcfBlob *inBlob = nullptr; // test api functions ret = mdObj->update(mdObj, inBlob); EXPECT_NE(ret, 0); @@ -153,7 +154,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest002, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, 0); @@ -168,8 +169,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest001, TestSize.Level0) ret = (int32_t)HcfMdCreate("SHA1", &mdObj); EXPECT_EQ(ret, 0); // set input and output buf - uint8_t outBuf[20] = {0}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob outBlob = {0}; // test api functions ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, 0); @@ -188,10 +188,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, 0); @@ -209,11 +208,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) HcfMd *mdObj = nullptr; ret = (int32_t)HcfMdCreate("SHA256", &mdObj); EXPECT_EQ(ret, 0); - // set input and output buf - uint8_t outBuf[20] = {0}; // define input and output data in blob form - HcfBlob inBlob= {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; - HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + HcfBlob inBlob = {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; + HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, 0); @@ -248,10 +245,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[20] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, 0); @@ -275,11 +271,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[28] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -304,11 +299,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[32] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -333,11 +327,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[48] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -363,11 +356,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[64] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -393,11 +385,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - uint8_t outBuf[16] = {0}; // define input and output data in blob form - struct HcfBlob inBlob= {.data = (uint8_t *)testData, .len = testDataLen}; - struct HcfBlob outBlob = {.data = (uint8_t *)outBuf, .len = 0}; + struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -411,4 +402,39 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); } + +static const char *GetInvalidMdClass(void) +{ + return "INVALID_MD_CLASS"; +} + +HWTEST_F(CryptoMdTest, InvalidInputMdTest001, TestSize.Level0) +{ + HcfResult ret = OpensslMdSpiCreate("SHA256", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) +{ + HcfMdSpi *spiObj = nullptr; + HcfMdSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidMdClass; + // set input and output blob + uint8_t testData[] = "My test data"; + uint32_t testDataLen = 12; + HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob outBlob = {0}; + HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + ret = spiObj->engineUpdateMd(&invalidSpi, &inBlob); + EXPECT_NE(ret, HCF_SUCCESS); + ret = spiObj->engineDoFinalMd(&invalidSpi, &outBlob); + EXPECT_NE(ret, HCF_SUCCESS); + uint32_t len = spiObj->engineGetMdLength(&invalidSpi); + EXPECT_EQ(len, 0); + HcfObjDestroy(spiObj); +} } \ No newline at end of file diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index 6383b34..ea0335f 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -17,6 +17,7 @@ #include "securec.h" #include "rand.h" +#include "rand_openssl.h" #include "log.h" #include "memory.h" @@ -66,9 +67,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t randomLen = 0; - uint8_t randomBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random with length 0 ret = randObj->generateRandom(randObj, randomLen, &randomBlob); EXPECT_NE(ret, 0); @@ -84,9 +84,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t randomLen = 32; - uint8_t randomBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); EXPECT_EQ(ret, 0); @@ -104,9 +103,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t randomLen = 8192; - uint8_t randomBuf[8192] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); EXPECT_EQ(ret, 0); @@ -124,9 +122,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest004, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t randomLen = 8193; - uint8_t randomBuf[8193] = {0}; // define randomBlob and seedBlob - struct HcfBlob randomBlob = {.data = (uint8_t *)randomBuf, .len = 0}; + struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); EXPECT_NE(ret, 0); @@ -159,9 +156,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t seedLen = 32; - uint8_t seedBuf[32] = {0}; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {.data = (uint8_t *)seedBuf, .len = 0}; + struct HcfBlob seedBlob = {0}; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); EXPECT_EQ(ret, 0); @@ -182,9 +178,8 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) EXPECT_EQ(ret, 0); // preset params int32_t seedLen = 1000; - uint8_t seedBuf[1000] = {0}; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {.data = (uint8_t *)seedBuf, .len = 0}; + struct HcfBlob seedBlob = {0}; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); EXPECT_EQ(ret, 0); @@ -195,4 +190,28 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) HcfBlobDataClearAndFree(&seedBlob); HcfObjDestroy(randObj); } + +static const char *GetInvalidRandClass(void) +{ + return "INVALID_RAND_CLASS"; +} + +HWTEST_F(CryptoRandTest, NullInputRandTest001, TestSize.Level0) +{ + HcfResult ret = HcfRandSpiCreate(nullptr); + EXPECT_NE(ret, HCF_SUCCESS); +} + +HWTEST_F(CryptoRandTest, InvalidSpiClassRandTest001, TestSize.Level0) +{ + HcfRandSpi *spiObj = nullptr; + HcfRandSpi invalidSpi = {{0}}; + invalidSpi.base.getClass = GetInvalidRandClass; + HcfResult ret = HcfRandSpiCreate(&spiObj); + EXPECT_EQ(ret, HCF_SUCCESS); + EXPECT_NE(spiObj, nullptr); + (void)spiObj->base.destroy(nullptr); + (void)spiObj->base.destroy(&(invalidSpi.base)); + HcfObjDestroy(spiObj); +} } \ No newline at end of file -- Gitee From bad66056e047ee72db8f981ed6860c34084875af Mon Sep 17 00:00:00 2001 From: quyawei Date: Fri, 11 Nov 2022 16:38:19 +0800 Subject: [PATCH 02/16] fix arr assign error Signed-off-by: quyawei --- plugin/openssl_plugin/rand/src/rand_openssl.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index a1a05a2..caf19e5 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -53,10 +53,7 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl static HcfResult OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { - int32_t seedLen = seed->len; - unsigned char seedBuf[seedLen]; - (void)memcpy_s(seedBuf, seedLen, seed->data, seedLen); - RAND_seed(seedBuf, seedLen); + RAND_seed(seed->data, seed->len); return HCF_SUCCESS; } -- Gitee From e454009e61ab40d4d4044afff5293fb6bf51549f Mon Sep 17 00:00:00 2001 From: quyawei Date: Fri, 11 Nov 2022 17:55:22 +0800 Subject: [PATCH 03/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 288 ++++++++++++-------------- 1 file changed, 132 insertions(+), 156 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index 90dadc9..b9c01c5 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -72,64 +72,58 @@ static void PrintfBlobInHex(uint8_t *data, size_t dataLen) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacCreateTest002, TestSize.Level0) { - int32_t ret = 0; - ret = (int32_t)HcfMacCreate("SHA1", nullptr); - EXPECT_NE(ret, 0); + HcfResult HcfResult ret = HcfMacCreate("SHA1", nullptr); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA3", &macObj); - EXPECT_NE(ret, 0); + HcfResult HcfResult ret = HcfMacCreate("SHA3", &macObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate(nullptr, &macObj); - EXPECT_NE(ret, 0); + HcfResult HcfResult ret = HcfMacCreate(nullptr, &macObj); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); // test api functions const char *algoName = macObj->getAlgoName(macObj); ret = strcmp(algoName, "SHA1"); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // set a nullptr key HcfSymKey *key = nullptr; // test api functions @@ -140,24 +134,23 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -165,16 +158,15 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions ret = macObj->update(macObj, &inBlob); EXPECT_NE(ret, 0); @@ -183,26 +175,25 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // define input and output data in blob form HcfBlob *inBlob = nullptr; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, inBlob); EXPECT_NE(ret, 0); HcfObjDestroy(macObj); @@ -212,31 +203,30 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -244,11 +234,10 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // set input and output buf HcfBlob outBlob = {0}; // test api functions @@ -260,35 +249,31 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); printf("get symkey finish"); // set input and output buf HcfBlob outBlob = {0}; - // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; printf("test init finish"); - ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; printf("test dofinal finish"); PrintfBlobInHex(outBlob.data, outBlob.len); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); printf("HcfBlobDataClearAndFree finish"); @@ -302,34 +287,33 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -339,31 +323,30 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA256", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; + HcfBlob inBlob = {.data = reinterpret_cast(g_testBigData), .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; HcfBlob outBlob = {0}; // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); @@ -374,37 +357,35 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // test api functions ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; HcfObjDestroy(macObj); } HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // cteate key generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 20); HcfObjDestroy(macObj); @@ -414,33 +395,32 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA1", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 20); // destroy the API obj and blob data @@ -452,33 +432,32 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA224", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA224", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 28); // destroy the API obj and blob data @@ -490,33 +469,32 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA256", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 32); // destroy the API obj and blob data @@ -528,33 +506,32 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA384", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA384", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 48); // destroy the API obj and blob data @@ -566,33 +543,32 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMac *macObj = nullptr; - ret = (int32_t)HcfMacCreate("SHA512", &macObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMacCreate("SHA512", &macObj); + EXPECT_EQ(ret, HCF_SUCCESS);; // create a symKey generator HcfSymKeyGenerator *generator = nullptr; - ret = (int32_t)HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, 0); + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + EXPECT_EQ(ret, HCF_SUCCESS);; // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, (HcfSymKey *)key); - EXPECT_EQ(ret, 0); + ret = macObj->init(macObj, reinterpret_cast(key)); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS);; ret = macObj->getMacLength(macObj); EXPECT_EQ(ret, 64); // destroy the API obj and blob data @@ -629,19 +605,19 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; HcfSymKey *key = nullptr; - HcfBlob keyMaterialBlob = {.data = (uint8_t *)testKey, .len = testKeyLen}; + HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; ret = OpensslMacSpiCreate("SHA256", &spiObj); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); - ret = spiObj->engineInitMac(&invalidSpi, (HcfSymKey *)key); + ret = spiObj->engineInitMac(&invalidSpi, reinterpret_cast(key)); EXPECT_NE(ret, HCF_SUCCESS); ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob); EXPECT_NE(ret, HCF_SUCCESS); -- Gitee From b4310b924db5470c91dec223dd94bf1ed457ded9 Mon Sep 17 00:00:00 2001 From: quyawei Date: Fri, 11 Nov 2022 18:02:15 +0800 Subject: [PATCH 04/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 150 +++++++++++++------------- 1 file changed, 75 insertions(+), 75 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index b9c01c5..95c77fd 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -72,7 +72,7 @@ static void PrintfBlobInHex(uint8_t *data, size_t dataLen) HWTEST_F(CryptoMacTest, CryptoFrameworkHmacCreateTest002, TestSize.Level0) { - HcfResult HcfResult ret = HcfMacCreate("SHA1", nullptr); + HcfResult ret = HcfMacCreate("SHA1", nullptr); EXPECT_NE(ret, HCF_SUCCESS); } @@ -80,7 +80,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest001, TestSize.Level0) { // create a SHA obj HcfMac *macObj = nullptr; - HcfResult HcfResult ret = HcfMacCreate("SHA1", &macObj); + HcfResult ret = HcfMacCreate("SHA1", &macObj); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); HcfObjDestroy(macObj); @@ -90,7 +90,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest002, TestSize.Level0) { // create a SHA obj HcfMac *macObj = nullptr; - HcfResult HcfResult ret = HcfMacCreate("SHA3", &macObj); + HcfResult ret = HcfMacCreate("SHA3", &macObj); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } @@ -99,7 +99,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest003, TestSize.Level0) { // create a SHA obj HcfMac *macObj = nullptr; - HcfResult HcfResult ret = HcfMacCreate(nullptr, &macObj); + HcfResult ret = HcfMacCreate(nullptr, &macObj); EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(macObj, nullptr); } @@ -108,7 +108,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0) { // create a SHA obj HcfMac *macObj = nullptr; - HcfResult HcfResult ret = HcfMacCreate("SHA1", &macObj); + HcfResult ret = HcfMacCreate("SHA1", &macObj); EXPECT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); // test api functions @@ -123,7 +123,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set a nullptr key HcfSymKey *key = nullptr; // test api functions @@ -137,11 +137,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -150,7 +150,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -161,7 +161,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; @@ -178,11 +178,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -193,7 +193,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) HcfBlob *inBlob = nullptr; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, inBlob); EXPECT_NE(ret, 0); HcfObjDestroy(macObj); @@ -206,11 +206,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) // create a API obj with SHA1 HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -224,9 +224,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -237,7 +237,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set input and output buf HcfBlob outBlob = {0}; // test api functions @@ -252,11 +252,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -268,10 +268,10 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); printf("test init finish"); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); printf("test dofinal finish"); PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data @@ -290,11 +290,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -309,11 +309,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -326,11 +326,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -342,11 +342,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); @@ -360,10 +360,10 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // test api functions - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 0); HcfObjDestroy(macObj); } @@ -372,11 +372,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -385,9 +385,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 20); HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -398,11 +398,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -416,13 +416,13 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 20); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -435,11 +435,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA224", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -453,13 +453,13 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 28); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 28); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -472,11 +472,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -490,13 +490,13 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 32); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 32); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -509,11 +509,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA384", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -527,13 +527,13 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 48); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 48); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -546,11 +546,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA512", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -564,13 +564,13 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) HcfBlob outBlob = {0}; // test api funcitons ret = macObj->init(macObj, reinterpret_cast(key)); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; + EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->doFinal(macObj, &outBlob); - EXPECT_EQ(ret, HCF_SUCCESS);; - ret = macObj->getMacLength(macObj); - EXPECT_EQ(ret, 64); + EXPECT_EQ(ret, HCF_SUCCESS); + uint32_t len = macObj->getMacLength(macObj); + EXPECT_EQ(len, 64); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); -- Gitee From d947e85193747d691efe3500bfd28ac514e3edda Mon Sep 17 00:00:00 2001 From: quyawei Date: Fri, 11 Nov 2022 18:09:37 +0800 Subject: [PATCH 05/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index 95c77fd..ffa7aa5 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -113,8 +113,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0) EXPECT_NE(macObj, nullptr); // test api functions const char *algoName = macObj->getAlgoName(macObj); - ret = strcmp(algoName, "SHA1"); - EXPECT_EQ(ret, HCF_SUCCESS); + int32_t cmpRes = strcmp(algoName, "SHA1"); + EXPECT_EQ(cmpRes, HCF_SUCCESS); HcfObjDestroy(macObj); } -- Gitee From 7a6958e495a915de5a03a4fbda8a927c3318df24 Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 10:13:35 +0800 Subject: [PATCH 06/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 2 +- test/unittest/src/crypto_md_test.cpp | 159 ++++++++++--------------- test/unittest/src/crypto_rand_test.cpp | 40 +++---- 3 files changed, 79 insertions(+), 122 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index ffa7aa5..d13e5b1 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -600,7 +600,7 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) // create a symKey generator HcfSymKeyGenerator *generator = nullptr; HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index a639104..0236c25 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -76,65 +76,59 @@ static void PrintfBlobInHex(uint8_t *data, size_t dataLen) */ HWTEST_F(CryptoMdTest, CryptoFrameworkMdCreateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj - ret = (int32_t)HcfMdCreate("SHA1", nullptr); + HcfResult ret = HcfMdCreate("SHA1", nullptr); EXPECT_NE(ret, 0); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(mdObj, nullptr); HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA3 obj (not supported) HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA3", &mdObj); + HcfResult ret = HcfMdCreate("SHA3", &mdObj); EXPECT_NE(ret, 0); EXPECT_EQ(mdObj, nullptr); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest003, TestSize.Level0) { - int32_t ret = 0; // create an obj with null algoInput (not supported) HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate(nullptr, &mdObj); + HcfResult ret = HcfMdCreate(nullptr, &mdObj); EXPECT_NE(ret, 0); EXPECT_EQ(mdObj, nullptr); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoNameTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(mdObj, nullptr); // test api functions const char *algoName = mdObj->getAlgoName(mdObj); - ret = strcmp(algoName, "SHA1"); - EXPECT_EQ(ret, 0); + int32_t cmpRes = strcmp(algoName, "SHA1"); + EXPECT_EQ(cmpRes, HCF_SUCCESS); HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form HcfBlob *inBlob = nullptr; // test api functions @@ -145,34 +139,32 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest001, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); HcfObjDestroy(mdObj); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest001, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf HcfBlob outBlob = {0}; // test api functions ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -180,22 +172,21 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest001, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -203,19 +194,18 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) { - int32_t ret = 0; // create a SHA1 obj HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA256", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA256", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form - HcfBlob inBlob = {.data = (uint8_t *)g_testBigData, .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; + HcfBlob inBlob = {.data = reinterpret_cast(g_testBigData), .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); PrintfBlobInHex(outBlob.data, outBlob.len); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); @@ -224,11 +214,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdLenTest001, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // test api functions ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 20); @@ -237,22 +226,21 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdLenTest001, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA1", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA1", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 20); // destroy the API obj and blob data @@ -262,28 +250,23 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA224", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA224", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; - // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 28); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -291,24 +274,21 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA256", &mdObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfMdCreate("SHA256", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; - // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 32); // destroy the API obj and blob data @@ -318,28 +298,23 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA384", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA384", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; - // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 48); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -347,28 +322,23 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("SHA512", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("SHA512", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; - // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 64); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -376,28 +346,23 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) { - int32_t ret = 0; // create a API obj with SHA1 HcfMd *mdObj = nullptr; - ret = (int32_t)HcfMdCreate("MD5", &mdObj); - EXPECT_EQ(ret, 0); - + HcfResult ret = HcfMdCreate("MD5", &mdObj); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; - // define input and output data in blob form - struct HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; struct HcfBlob outBlob = {0}; - // test api functions ret = mdObj->update(mdObj, &inBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); EXPECT_EQ(ret, 16); - // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -422,10 +387,10 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = (uint8_t *)testData, .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; HcfBlob outBlob = {0}; HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index ea0335f..874a5a2 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -53,18 +53,16 @@ void CryptoRandTest::TearDown() // add destroy here, this will be called when te */ HWTEST_F(CryptoRandTest, CryptoFrameworkRandCreateTest001, TestSize.Level0) { - int32_t ret = 0; - ret = (int32_t)HcfRandCreate(nullptr); + HcfResult ret = HcfRandCreate(nullptr); EXPECT_NE(ret, 0); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t randomLen = 0; // define randomBlob and seedBlob @@ -77,11 +75,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t randomLen = 32; // define randomBlob and seedBlob @@ -96,11 +93,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t randomLen = 8192; // define randomBlob and seedBlob @@ -115,11 +111,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest004, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t randomLen = 8193; // define randomBlob and seedBlob @@ -133,11 +128,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest004, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest001, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // define randomBlob and seedBlob struct HcfBlob *seedBlob = nullptr; // test set seed @@ -149,11 +143,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest001, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t seedLen = 32; // define randomBlob and seedBlob @@ -171,11 +164,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) { - int32_t ret = 0; // create a rand obj HcfRand *randObj = nullptr; - ret = (int32_t)HcfRandCreate(&randObj); - EXPECT_EQ(ret, 0); + HcfResult ret = HcfRandCreate(&randObj); + ASSERT_EQ(ret, 0); // preset params int32_t seedLen = 1000; // define randomBlob and seedBlob @@ -208,7 +200,7 @@ HWTEST_F(CryptoRandTest, InvalidSpiClassRandTest001, TestSize.Level0) HcfRandSpi invalidSpi = {{0}}; invalidSpi.base.getClass = GetInvalidRandClass; HcfResult ret = HcfRandSpiCreate(&spiObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); -- Gitee From ece3aa0d5d5b007b530f95b8b8fce2a6d448b9ca Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 10:40:36 +0800 Subject: [PATCH 07/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 33 +++++++++------- test/unittest/src/crypto_md_test.cpp | 52 +++++++++++++++----------- test/unittest/src/crypto_rand_test.cpp | 12 +++--- 3 files changed, 56 insertions(+), 41 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index d13e5b1..8565a71 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -36,6 +36,14 @@ public: void TearDown(); }; +constexpr uint32_t MAX_MAC_BLOB_LEN = 5000; +constexpr uint32_t INVALID_LEN = 0; +constexpr uint32_t SHA1_LEN = 20; +constexpr uint32_t SHA224_LEN = 28; +constexpr uint32_t SHA256_LEN = 32; +constexpr uint32_t SHA384_LEN = 48; +constexpr uint32_t SHA512_LEN = 64; + static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n" "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n" "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n" @@ -49,7 +57,6 @@ static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhj "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n" "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n" "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n"; -constexpr uint32_t MAX_MAC_BLOB_LEN = 5000; void CryptoMacTest::SetUpTestCase() {} void CryptoMacTest::TearDownTestCase() {} @@ -128,7 +135,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) HcfSymKey *key = nullptr; // test api functions ret = macObj->init(macObj, key); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); HcfObjDestroy(macObj); } @@ -169,7 +176,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions ret = macObj->update(macObj, &inBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); HcfObjDestroy(macObj); } @@ -195,7 +202,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) ret = macObj->init(macObj, reinterpret_cast(key)); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, inBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -242,7 +249,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) HcfBlob outBlob = {0}; // test api functions ret = macObj->doFinal(macObj, &outBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfObjDestroy(macObj); } @@ -363,7 +370,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0) EXPECT_EQ(ret, HCF_SUCCESS); // test api functions uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 0); + EXPECT_EQ(len, INVALID_LEN); HcfObjDestroy(macObj); } @@ -387,7 +394,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) ret = macObj->init(macObj, reinterpret_cast(key)); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 20); + EXPECT_EQ(len, SHA1_LEN); HcfObjDestroy(macObj); HcfObjDestroy(key); HcfObjDestroy(generator); @@ -422,7 +429,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) ret = macObj->doFinal(macObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 20); + EXPECT_EQ(len, SHA1_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -459,7 +466,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) ret = macObj->doFinal(macObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 28); + EXPECT_EQ(len, SHA224_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -496,7 +503,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) ret = macObj->doFinal(macObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 32); + EXPECT_EQ(len, SHA256_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -533,7 +540,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) ret = macObj->doFinal(macObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 48); + EXPECT_EQ(len, SHA384_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -570,7 +577,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) ret = macObj->doFinal(macObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); - EXPECT_EQ(len, 64); + EXPECT_EQ(len, SHA512_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(macObj); @@ -624,7 +631,7 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob); EXPECT_NE(ret, HCF_SUCCESS); uint32_t len = spiObj->engineGetMacLength(&invalidSpi); - EXPECT_EQ(len, 0); + EXPECT_EQ(len, INVALID_LEN); HcfObjDestroy(spiObj); HcfObjDestroy(key); HcfObjDestroy(generator); diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index 0236c25..201b67f 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -34,6 +34,15 @@ public: void TearDown(); }; +constexpr uint32_t MAX_MD_BLOB_LEN = 5000; +constexpr uint32_t INVALID_LEN = 0; +constexpr uint32_t SHA1_LEN = 20; +constexpr uint32_t SHA224_LEN = 28; +constexpr uint32_t SHA256_LEN = 32; +constexpr uint32_t SHA384_LEN = 48; +constexpr uint32_t SHA512_LEN = 64; +constexpr uint32_t MD5_LEN = 16; + static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n" "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n" "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n" @@ -47,7 +56,6 @@ static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhj "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n" "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n" "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n"; -constexpr uint32_t MAX_MD_BLOB_LEN = 5000; void CryptoMdTest::SetUpTestCase() {} void CryptoMdTest::TearDownTestCase() {} @@ -78,7 +86,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdCreateTest001, TestSize.Level0) { // create a SHA1 obj HcfResult ret = HcfMdCreate("SHA1", nullptr); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest001, TestSize.Level0) @@ -96,7 +104,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest002, TestSize.Level0) // create a SHA3 obj (not supported) HcfMd *mdObj = nullptr; HcfResult ret = HcfMdCreate("SHA3", &mdObj); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(mdObj, nullptr); } @@ -105,7 +113,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest003, TestSize.Level0) // create an obj with null algoInput (not supported) HcfMd *mdObj = nullptr; HcfResult ret = HcfMdCreate(nullptr, &mdObj); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); EXPECT_EQ(mdObj, nullptr); } @@ -133,7 +141,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest001, TestSize.Level0) HcfBlob *inBlob = nullptr; // test api functions ret = mdObj->update(mdObj, inBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); HcfObjDestroy(mdObj); } @@ -147,7 +155,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest002, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -180,7 +188,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -220,7 +228,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdLenTest001, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // test api functions ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, SHA1_LEN); HcfObjDestroy(mdObj); } @@ -234,7 +242,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -242,7 +250,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 20); + EXPECT_EQ(ret, SHA1_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -258,7 +266,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -266,7 +274,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 28); + EXPECT_EQ(ret, SHA224_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -282,7 +290,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -290,7 +298,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 32); + EXPECT_EQ(ret, SHA256_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -306,7 +314,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -314,7 +322,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 48); + EXPECT_EQ(ret, SHA384_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -330,7 +338,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -338,7 +346,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 64); + EXPECT_EQ(ret, SHA512_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -354,7 +362,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -362,7 +370,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, 16); + EXPECT_EQ(ret, MD5_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -387,7 +395,7 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testKey), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; HcfBlob outBlob = {0}; HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); ASSERT_EQ(ret, HCF_SUCCESS); @@ -399,7 +407,7 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) ret = spiObj->engineDoFinalMd(&invalidSpi, &outBlob); EXPECT_NE(ret, HCF_SUCCESS); uint32_t len = spiObj->engineGetMdLength(&invalidSpi); - EXPECT_EQ(len, 0); + EXPECT_EQ(len, INVALID_LEN); HcfObjDestroy(spiObj); } } \ No newline at end of file diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index 874a5a2..9e5da36 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -85,7 +85,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&randomBlob); HcfObjDestroy(randObj); @@ -103,7 +103,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&randomBlob); HcfObjDestroy(randObj); @@ -153,10 +153,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) struct HcfBlob seedBlob = {0}; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // test set seed ret = randObj->setSeed(randObj, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&seedBlob); HcfObjDestroy(randObj); @@ -174,10 +174,10 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) struct HcfBlob seedBlob = {0}; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // test set seed ret = randObj->setSeed(randObj, &seedBlob); - EXPECT_EQ(ret, 0); + EXPECT_EQ(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfBlobDataClearAndFree(&seedBlob); HcfObjDestroy(randObj); -- Gitee From a62a866b9f6278137b6c9e4bfbf80279e26cb603 Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 10:49:31 +0800 Subject: [PATCH 08/16] update TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_md_test.cpp | 44 ++++++++++++++-------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index 201b67f..a42b026 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -188,7 +188,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -227,8 +227,8 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdLenTest001, TestSize.Level0) HcfResult ret = HcfMdCreate("SHA1", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); // test api functions - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA1_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA1_LEN); HcfObjDestroy(mdObj); } @@ -242,15 +242,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA1_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA1_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -266,15 +266,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA224_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA224_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -290,15 +290,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA256_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA256_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -314,15 +314,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA384_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA384_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -338,15 +338,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, SHA512_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, SHA512_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -362,15 +362,15 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) uint8_t testData[] = "My test data"; size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; struct HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); - ret = mdObj->getMdLength(mdObj); - EXPECT_EQ(ret, MD5_LEN); + uint32_t len = mdObj->getMdLength(mdObj); + EXPECT_EQ(len, MD5_LEN); // destroy the API obj and blob data HcfBlobDataClearAndFree(&outBlob); HcfObjDestroy(mdObj); @@ -395,7 +395,7 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) // set input and output blob uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testdata), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); ASSERT_EQ(ret, HCF_SUCCESS); -- Gitee From a1d8797a130509b754a5792fef302af9ce950a06 Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 11:02:24 +0800 Subject: [PATCH 09/16] TDD cases update Signed-off-by: quyawei --- .vscode/settings.json | 8 ++++++++ plugin/openssl_plugin/common/inc/openssl_common.h | 1 + .../crypto_operation/hmac/src/mac_openssl.c | 2 +- .../openssl_plugin/crypto_operation/md/src/md_openssl.c | 4 ++-- 4 files changed, 12 insertions(+), 3 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..59b5386 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,8 @@ +{ + "files.associations": { + "config.h": "c", + "memory.h": "c", + "utils.h": "c", + "openssl_common.h": "c" + } +} \ No newline at end of file diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index 0ac660d..90b5764 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -24,6 +24,7 @@ #define HCF_OPENSSL_SUCCESS 1 /* openssl return 1: success */ #define HCF_BITS_PER_BYTE 8 +#define HCF_OPENSSL_INVALID_LEN 0 #ifdef __cplusplus extern "C" { diff --git a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c index a63b601..f411aa8 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c @@ -134,7 +134,7 @@ static uint32_t OpensslEngineGetMacLength(HcfMacSpi *self) { if (OpensslGetMacCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return 0; + return HCF_OPENSSL_INVALID_LEN; } return HMAC_size(OpensslGetMacCtx(self)); } 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 6e32acd..ae86505 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -107,12 +107,12 @@ static uint32_t OpensslEngineGetMdLength(HcfMdSpi *self) { if (OpensslGetMdCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return 0; + return HCF_OPENSSL_INVALID_LEN; } int32_t size = EVP_MD_CTX_size(OpensslGetMdCtx(self)); if (size < 0) { LOGE("Get the overflow path length in openssl!"); - return 0; + return HCF_OPENSSL_INVALID_LEN; } return size; } -- Gitee From eb54894ceee5aac188953aed75cc08510df7afae Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 11:58:18 +0800 Subject: [PATCH 10/16] TDD cases update Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 4 +++- test/unittest/src/crypto_md_test.cpp | 6 ++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index 8565a71..b40587c 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -345,7 +345,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(g_testBigData), .len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN)}; + HcfBlob inBlob = {0}; + inBlob.data = reinterpret_cast(g_testBigData); + inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN); HcfBlob outBlob = {0}; // test api functions ret = macObj->init(macObj, reinterpret_cast(key)); diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index a42b026..dc62991 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -207,7 +207,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) HcfResult ret = HcfMdCreate("SHA256", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(g_testBigData), .len = strnlen(g_testBigData, MAX_MD_BLOB_LEN)}; + HcfBlob inBlob = {0}; + inBlob.data = reinterpret_cast(g_testBigData); + inBlob.len = strnlen(g_testBigData, MAX_MD_BLOB_LEN); HcfBlob outBlob = {0}; // test api functions ret = mdObj->update(mdObj, &inBlob); @@ -261,7 +263,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) // create a API obj with SHA1 HcfMd *mdObj = nullptr; HcfResult ret = HcfMdCreate("SHA224", &mdObj); - ASSERT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; size_t testDataLen = 12; -- Gitee From 91f497dc33073a990542d8579157ee6f73ef7e26 Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 14:38:27 +0800 Subject: [PATCH 11/16] update OpensslSetSeed func to void return Signed-off-by: quyawei --- frameworks/rand/rand.c | 3 ++- frameworks/spi/rand_spi.h | 2 +- plugin/openssl_plugin/rand/src/rand_openssl.c | 3 +-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/frameworks/rand/rand.c b/frameworks/rand/rand.c index 4681bfa..39427b6 100644 --- a/frameworks/rand/rand.c +++ b/frameworks/rand/rand.c @@ -82,8 +82,9 @@ static HcfResult SetSeed(HcfRand *self, HcfBlob *seed) LOGE("Class is not match."); return HCF_INVALID_PARAMS; } - return ((HcfRandImpl *)self)->spiObj->engineSetSeed( + ((HcfRandImpl *)self)->spiObj->engineSetSeed( ((HcfRandImpl *)self)->spiObj, seed); + return HCF_SUCCESS; } static void HcfRandDestroy(HcfObjectBase *self) diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 6c81b51..5825d79 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -28,7 +28,7 @@ struct HcfRandSpi { HcfResult (*engineGenerateRandom)(HcfRandSpi *self, int32_t numBytes, HcfBlob *random); - HcfResult (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); + void (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); }; #endif \ No newline at end of file diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index caf19e5..573639e 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -51,10 +51,9 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl return HCF_SUCCESS; } -static HcfResult OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) +static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) { RAND_seed(seed->data, seed->len); - return HCF_SUCCESS; } static void DestroyRandOpenssl(HcfObjectBase *self) -- Gitee From ddea8281485d0a49b07da562dc3732ab5318d640 Mon Sep 17 00:00:00 2001 From: quyawei Date: Mon, 14 Nov 2022 15:31:36 +0800 Subject: [PATCH 12/16] update macro defines and remove OpensslSetSeed func Signed-off-by: quyawei --- .vscode/settings.json | 8 --- frameworks/rand/rand.c | 5 +- frameworks/spi/rand_spi.h | 2 - .../common/inc/openssl_common.h | 1 - .../crypto_operation/hmac/inc/mac_openssl.h | 2 + .../crypto_operation/hmac/src/mac_openssl.c | 2 +- .../crypto_operation/md/inc/md_openssl.h | 2 + .../crypto_operation/md/src/md_openssl.c | 4 +- plugin/openssl_plugin/rand/src/rand_openssl.c | 6 -- test/unittest/src/crypto_mac_test.cpp | 62 +++++++++---------- test/unittest/src/crypto_md_test.cpp | 6 +- test/unittest/src/crypto_rand_test.cpp | 24 +++---- 12 files changed, 56 insertions(+), 68 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 59b5386..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "files.associations": { - "config.h": "c", - "memory.h": "c", - "utils.h": "c", - "openssl_common.h": "c" - } -} \ No newline at end of file diff --git a/frameworks/rand/rand.c b/frameworks/rand/rand.c index 39427b6..3e32c2f 100644 --- a/frameworks/rand/rand.c +++ b/frameworks/rand/rand.c @@ -22,6 +22,8 @@ #include "memory.h" #include "utils.h" +#include + typedef HcfResult (*HcfRandSpiCreateFunc)(HcfRandSpi **); typedef struct { @@ -82,8 +84,7 @@ static HcfResult SetSeed(HcfRand *self, HcfBlob *seed) LOGE("Class is not match."); return HCF_INVALID_PARAMS; } - ((HcfRandImpl *)self)->spiObj->engineSetSeed( - ((HcfRandImpl *)self)->spiObj, seed); + RAND_seed(seed->data, seed->len); return HCF_SUCCESS; } diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 5825d79..47ae71f 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -27,8 +27,6 @@ struct HcfRandSpi { HcfObjectBase base; HcfResult (*engineGenerateRandom)(HcfRandSpi *self, int32_t numBytes, HcfBlob *random); - - void (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); }; #endif \ No newline at end of file diff --git a/plugin/openssl_plugin/common/inc/openssl_common.h b/plugin/openssl_plugin/common/inc/openssl_common.h index 90b5764..0ac660d 100644 --- a/plugin/openssl_plugin/common/inc/openssl_common.h +++ b/plugin/openssl_plugin/common/inc/openssl_common.h @@ -24,7 +24,6 @@ #define HCF_OPENSSL_SUCCESS 1 /* openssl return 1: success */ #define HCF_BITS_PER_BYTE 8 -#define HCF_OPENSSL_INVALID_LEN 0 #ifdef __cplusplus extern "C" { diff --git a/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h b/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h index c70c390..419dc30 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/hmac/inc/mac_openssl.h @@ -17,6 +17,8 @@ #include "mac_spi.h" +#define HCF_OPENSSL_INVALID_MAC_LEN 0 + #ifdef __cplusplus extern "C" { #endif diff --git a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c index f411aa8..958ffa9 100644 --- a/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/hmac/src/mac_openssl.c @@ -134,7 +134,7 @@ static uint32_t OpensslEngineGetMacLength(HcfMacSpi *self) { if (OpensslGetMacCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return HCF_OPENSSL_INVALID_LEN; + return HCF_OPENSSL_INVALID_MAC_LEN; } return HMAC_size(OpensslGetMacCtx(self)); } diff --git a/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h b/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h index 4a62432..fb4716e 100644 --- a/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h +++ b/plugin/openssl_plugin/crypto_operation/md/inc/md_openssl.h @@ -17,6 +17,8 @@ #include "md_spi.h" +#define HCF_OPENSSL_INVALID_MD_LEN 0 + #ifdef __cplusplus extern "C" { #endif 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 ae86505..a7aa197 100644 --- a/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/md/src/md_openssl.c @@ -107,12 +107,12 @@ static uint32_t OpensslEngineGetMdLength(HcfMdSpi *self) { if (OpensslGetMdCtx(self) == NULL) { LOGE("The CTX is NULL!"); - return HCF_OPENSSL_INVALID_LEN; + return HCF_OPENSSL_INVALID_MD_LEN; } int32_t size = EVP_MD_CTX_size(OpensslGetMdCtx(self)); if (size < 0) { LOGE("Get the overflow path length in openssl!"); - return HCF_OPENSSL_INVALID_LEN; + return HCF_OPENSSL_INVALID_MD_LEN; } return size; } diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index 573639e..fdb6578 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -51,11 +51,6 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl return HCF_SUCCESS; } -static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) -{ - RAND_seed(seed->data, seed->len); -} - static void DestroyRandOpenssl(HcfObjectBase *self) { if (self == NULL) { @@ -83,7 +78,6 @@ HcfResult HcfRandSpiCreate(HcfRandSpi **spiObj) returnSpiImpl->base.base.getClass = GetRandOpenSSLClass; returnSpiImpl->base.base.destroy = DestroyRandOpenssl; returnSpiImpl->base.engineGenerateRandom = OpensslGenerateRandom; - returnSpiImpl->base.engineSetSeed = OpensslSetSeed; *spiObj = (HcfRandSpi *)returnSpiImpl; return HCF_SUCCESS; } \ No newline at end of file diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index b40587c..f075648 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -88,7 +88,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest001, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); HcfObjDestroy(macObj); } @@ -116,7 +116,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); EXPECT_NE(macObj, nullptr); // test api functions const char *algoName = macObj->getAlgoName(macObj); @@ -130,7 +130,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set a nullptr key HcfSymKey *key = nullptr; // test api functions @@ -144,11 +144,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) // create a SHA obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -168,7 +168,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; uint32_t testDataLen = 12; @@ -185,11 +185,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -213,11 +213,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) // create a API obj with SHA1 HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -244,7 +244,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf HcfBlob outBlob = {0}; // test api functions @@ -259,11 +259,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator and set key text HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -297,11 +297,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -333,11 +333,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -369,7 +369,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // test api functions uint32_t len = macObj->getMacLength(macObj); EXPECT_EQ(len, INVALID_LEN); @@ -381,11 +381,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // cteate key generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // get sym key from preset keyBlob uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -407,11 +407,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA1", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -444,11 +444,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA224", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -481,11 +481,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA256", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -518,11 +518,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA384", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -555,11 +555,11 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) // create a SHA1 obj HcfMac *macObj = nullptr; HcfResult ret = HcfMacCreate("SHA512", &macObj); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // create a symKey generator HcfSymKeyGenerator *generator = nullptr; ret = HcfSymKeyGeneratorCreate("AES128", &generator); - EXPECT_EQ(ret, HCF_SUCCESS); + ASSERT_EQ(ret, HCF_SUCCESS); // set key data and convert it to key obj uint8_t testKey[] = "abcdefghijklmnop"; uint32_t testKeyLen = 16; @@ -623,7 +623,7 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) HcfBlob outBlob = {0}; ret = OpensslMacSpiCreate("SHA256", &spiObj); EXPECT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(spiObj, nullptr); + ASSERT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); ret = spiObj->engineInitMac(&invalidSpi, reinterpret_cast(key)); diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index dc62991..2c52582 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -95,7 +95,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoSuppTest001, TestSize.Level0) HcfMd *mdObj = nullptr; HcfResult ret = HcfMdCreate("SHA1", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(mdObj, nullptr); + ASSERT_NE(mdObj, nullptr); HcfObjDestroy(mdObj); } @@ -123,7 +123,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoNameTest001, TestSize.Level0) HcfMd *mdObj = nullptr; HcfResult ret = HcfMdCreate("SHA1", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(mdObj, nullptr); + ASSERT_NE(mdObj, nullptr); // test api functions const char *algoName = mdObj->getAlgoName(mdObj); int32_t cmpRes = strcmp(algoName, "SHA1"); @@ -401,7 +401,7 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) HcfBlob outBlob = {0}; HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); ASSERT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(spiObj, nullptr); + ASSERT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); ret = spiObj->engineUpdateMd(&invalidSpi, &inBlob); diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index 9e5da36..6b35da3 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -54,7 +54,7 @@ void CryptoRandTest::TearDown() // add destroy here, this will be called when te HWTEST_F(CryptoRandTest, CryptoFrameworkRandCreateTest001, TestSize.Level0) { HcfResult ret = HcfRandCreate(nullptr); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); } HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) @@ -62,14 +62,14 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest001, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 0; // define randomBlob and seedBlob struct HcfBlob randomBlob = {0}; // test generate random with length 0 ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); HcfObjDestroy(randObj); } @@ -78,7 +78,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest002, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 32; // define randomBlob and seedBlob @@ -96,7 +96,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest003, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 8192; // define randomBlob and seedBlob @@ -114,14 +114,14 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkRandGenerateTest004, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t randomLen = 8193; // define randomBlob and seedBlob struct HcfBlob randomBlob = {0}; // test generate random ret = randObj->generateRandom(randObj, randomLen, &randomBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfObjDestroy(randObj); } @@ -131,12 +131,12 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest001, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // define randomBlob and seedBlob struct HcfBlob *seedBlob = nullptr; // test set seed ret = randObj->setSeed(randObj, seedBlob); - EXPECT_NE(ret, 0); + EXPECT_NE(ret, HCF_SUCCESS); // destroy the API obj and blob data HcfObjDestroy(randObj); } @@ -146,7 +146,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t seedLen = 32; // define randomBlob and seedBlob @@ -167,7 +167,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) // create a rand obj HcfRand *randObj = nullptr; HcfResult ret = HcfRandCreate(&randObj); - ASSERT_EQ(ret, 0); + ASSERT_EQ(ret, HCF_SUCCESS); // preset params int32_t seedLen = 1000; // define randomBlob and seedBlob @@ -201,7 +201,7 @@ HWTEST_F(CryptoRandTest, InvalidSpiClassRandTest001, TestSize.Level0) invalidSpi.base.getClass = GetInvalidRandClass; HcfResult ret = HcfRandSpiCreate(&spiObj); ASSERT_EQ(ret, HCF_SUCCESS); - EXPECT_NE(spiObj, nullptr); + ASSERT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); HcfObjDestroy(spiObj); -- Gitee From b99f2f5052f08dc4791d6ee360ae20027d8358b2 Mon Sep 17 00:00:00 2001 From: quyawei Date: Tue, 15 Nov 2022 14:21:10 +0800 Subject: [PATCH 13/16] add OpensslSetSeed func Signed-off-by: quyawei --- frameworks/rand/rand.c | 2 -- frameworks/spi/rand_spi.h | 2 ++ plugin/openssl_plugin/rand/src/rand_openssl.c | 6 ++++++ 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/frameworks/rand/rand.c b/frameworks/rand/rand.c index 3e32c2f..fca8b71 100644 --- a/frameworks/rand/rand.c +++ b/frameworks/rand/rand.c @@ -22,8 +22,6 @@ #include "memory.h" #include "utils.h" -#include - typedef HcfResult (*HcfRandSpiCreateFunc)(HcfRandSpi **); typedef struct { diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 47ae71f..5825d79 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -27,6 +27,8 @@ struct HcfRandSpi { HcfObjectBase base; HcfResult (*engineGenerateRandom)(HcfRandSpi *self, int32_t numBytes, HcfBlob *random); + + void (*engineSetSeed)(HcfRandSpi *self, HcfBlob *seed); }; #endif \ No newline at end of file diff --git a/plugin/openssl_plugin/rand/src/rand_openssl.c b/plugin/openssl_plugin/rand/src/rand_openssl.c index fdb6578..573639e 100644 --- a/plugin/openssl_plugin/rand/src/rand_openssl.c +++ b/plugin/openssl_plugin/rand/src/rand_openssl.c @@ -51,6 +51,11 @@ static HcfResult OpensslGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBl return HCF_SUCCESS; } +static void OpensslSetSeed(HcfRandSpi *self, HcfBlob *seed) +{ + RAND_seed(seed->data, seed->len); +} + static void DestroyRandOpenssl(HcfObjectBase *self) { if (self == NULL) { @@ -78,6 +83,7 @@ HcfResult HcfRandSpiCreate(HcfRandSpi **spiObj) returnSpiImpl->base.base.getClass = GetRandOpenSSLClass; returnSpiImpl->base.base.destroy = DestroyRandOpenssl; returnSpiImpl->base.engineGenerateRandom = OpensslGenerateRandom; + returnSpiImpl->base.engineSetSeed = OpensslSetSeed; *spiObj = (HcfRandSpi *)returnSpiImpl; return HCF_SUCCESS; } \ No newline at end of file -- Gitee From 8cf34cbda93dda3945d9d53f059ffe3bf096a11c Mon Sep 17 00:00:00 2001 From: quyawei Date: Tue, 15 Nov 2022 14:24:02 +0800 Subject: [PATCH 14/16] remove unnecessary casts in TDD cases Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index f075648..d2977b4 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -156,7 +156,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0) HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); HcfObjDestroy(macObj); HcfObjDestroy(key); @@ -199,7 +199,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0) // define input and output data in blob form HcfBlob *inBlob = nullptr; // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, inBlob); EXPECT_NE(ret, HCF_SUCCESS); @@ -230,7 +230,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) // define input and output data in blob form HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -274,7 +274,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) // set input and output buf HcfBlob outBlob = {0}; // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); printf("test init finish"); ret = macObj->doFinal(macObj, &outBlob); @@ -315,7 +315,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -350,7 +350,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN); HcfBlob outBlob = {0}; // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -393,7 +393,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0) HcfBlob keyMaterialBlob = {.data = reinterpret_cast(testKey), .len = testKeyLen}; generator->convertSymKey(generator, &keyMaterialBlob, &key); // test api functions - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); uint32_t len = macObj->getMacLength(macObj); EXPECT_EQ(len, SHA1_LEN); @@ -424,7 +424,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -461,7 +461,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -498,7 +498,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -535,7 +535,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -572,7 +572,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; HcfBlob outBlob = {0}; // test api funcitons - ret = macObj->init(macObj, reinterpret_cast(key)); + ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); ret = macObj->update(macObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -626,7 +626,7 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) ASSERT_NE(spiObj, nullptr); (void)spiObj->base.destroy(nullptr); (void)spiObj->base.destroy(&(invalidSpi.base)); - ret = spiObj->engineInitMac(&invalidSpi, reinterpret_cast(key)); + ret = spiObj->engineInitMac(&invalidSpi, key); EXPECT_NE(ret, HCF_SUCCESS); ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob); EXPECT_NE(ret, HCF_SUCCESS); -- Gitee From 83bd7c7bf12e149f53d20ba4a9d2e8cfa4f8675e Mon Sep 17 00:00:00 2001 From: quyawei Date: Tue, 15 Nov 2022 14:32:45 +0800 Subject: [PATCH 15/16] rand setSeed func update Signed-off-by: quyawei --- frameworks/rand/rand.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/frameworks/rand/rand.c b/frameworks/rand/rand.c index fca8b71..39427b6 100644 --- a/frameworks/rand/rand.c +++ b/frameworks/rand/rand.c @@ -82,7 +82,8 @@ static HcfResult SetSeed(HcfRand *self, HcfBlob *seed) LOGE("Class is not match."); return HCF_INVALID_PARAMS; } - RAND_seed(seed->data, seed->len); + ((HcfRandImpl *)self)->spiObj->engineSetSeed( + ((HcfRandImpl *)self)->spiObj, seed); return HCF_SUCCESS; } -- Gitee From cb0a991dbcc23f75dcce6b02aa52eee78800cb99 Mon Sep 17 00:00:00 2001 From: quyawei Date: Tue, 15 Nov 2022 14:51:07 +0800 Subject: [PATCH 16/16] use sizeof func instead of pre-set variables Signed-off-by: quyawei --- test/unittest/src/crypto_mac_test.cpp | 47 ++++++++++-------------- test/unittest/src/crypto_md_test.cpp | 49 +++++++++++--------------- test/unittest/src/crypto_rand_test.cpp | 4 +-- 3 files changed, 41 insertions(+), 59 deletions(-) diff --git a/test/unittest/src/crypto_mac_test.cpp b/test/unittest/src/crypto_mac_test.cpp index d2977b4..700d8ce 100644 --- a/test/unittest/src/crypto_mac_test.cpp +++ b/test/unittest/src/crypto_mac_test.cpp @@ -171,9 +171,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions ret = macObj->update(macObj, &inBlob); EXPECT_NE(ret, HCF_SUCCESS); @@ -226,9 +225,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -246,7 +244,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0) HcfResult ret = HcfMacCreate("SHA1", &macObj); ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf - HcfBlob outBlob = {0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = macObj->doFinal(macObj, &outBlob); EXPECT_NE(ret, HCF_SUCCESS); @@ -272,7 +270,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); printf("get symkey finish"); // set input and output buf - HcfBlob outBlob = {0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -310,10 +308,9 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -348,7 +345,7 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0) HcfBlob inBlob = {0}; inBlob.data = reinterpret_cast(g_testBigData); inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN); - HcfBlob outBlob = {0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -420,9 +417,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -457,9 +453,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -494,9 +489,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -531,9 +525,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -568,9 +561,8 @@ HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api funcitons ret = macObj->init(macObj, key); EXPECT_EQ(ret, HCF_SUCCESS); @@ -618,9 +610,8 @@ HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0) generator->convertSymKey(generator, &keyMaterialBlob, &key); // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; ret = OpensslMacSpiCreate("SHA256", &spiObj); EXPECT_EQ(ret, HCF_SUCCESS); ASSERT_NE(spiObj, nullptr); diff --git a/test/unittest/src/crypto_md_test.cpp b/test/unittest/src/crypto_md_test.cpp index 2c52582..fdc18d3 100644 --- a/test/unittest/src/crypto_md_test.cpp +++ b/test/unittest/src/crypto_md_test.cpp @@ -153,9 +153,8 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdUpdateTest002, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -169,7 +168,7 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest001, TestSize.Level0) HcfResult ret = HcfMdCreate("SHA1", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf - HcfBlob outBlob = {0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->doFinal(mdObj, &outBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -186,10 +185,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest002, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; // define input and output data in blob form - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -207,10 +205,10 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdDoFinalTest003, TestSize.Level0) HcfResult ret = HcfMdCreate("SHA256", &mdObj); ASSERT_EQ(ret, HCF_SUCCESS); // define input and output data in blob form - HcfBlob inBlob = {0}; + HcfBlob inBlob = { .data = nullptr, .len = 0 }; inBlob.data = reinterpret_cast(g_testBigData); inBlob.len = strnlen(g_testBigData, MAX_MD_BLOB_LEN); - HcfBlob outBlob = {0}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -242,10 +240,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest001, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -266,10 +263,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest002, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -290,10 +286,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest003, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -314,10 +309,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest004, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -338,10 +332,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest005, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -362,10 +355,9 @@ HWTEST_F(CryptoMdTest, CryptoFrameworkMdAlgoTest006, TestSize.Level0) ASSERT_EQ(ret, HCF_SUCCESS); // set input and output buf uint8_t testData[] = "My test data"; - size_t testDataLen = 12; // define input and output data in blob form - struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - struct HcfBlob outBlob = {0}; + struct HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + struct HcfBlob outBlob = { .data = nullptr, .len = 0 }; // test api functions ret = mdObj->update(mdObj, &inBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -396,9 +388,8 @@ HWTEST_F(CryptoMdTest, InvalidSpiClassMdTest001, TestSize.Level0) invalidSpi.base.getClass = GetInvalidMdClass; // set input and output blob uint8_t testData[] = "My test data"; - uint32_t testDataLen = 12; - HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = testDataLen}; - HcfBlob outBlob = {0}; + HcfBlob inBlob = {.data = reinterpret_cast(testData), .len = sizeof(testData)}; + HcfBlob outBlob = { .data = nullptr, .len = 0 }; HcfResult ret = OpensslMdSpiCreate("SHA256", &spiObj); ASSERT_EQ(ret, HCF_SUCCESS); ASSERT_NE(spiObj, nullptr); diff --git a/test/unittest/src/crypto_rand_test.cpp b/test/unittest/src/crypto_rand_test.cpp index 6b35da3..ab1c99d 100644 --- a/test/unittest/src/crypto_rand_test.cpp +++ b/test/unittest/src/crypto_rand_test.cpp @@ -150,7 +150,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest002, TestSize.Level0) // preset params int32_t seedLen = 32; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {0}; + struct HcfBlob seedBlob = { .data = nullptr, .len = 0 }; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); EXPECT_EQ(ret, HCF_SUCCESS); @@ -171,7 +171,7 @@ HWTEST_F(CryptoRandTest, CryptoFrameworkSetSeedTest003, TestSize.Level0) // preset params int32_t seedLen = 1000; // define randomBlob and seedBlob - struct HcfBlob seedBlob = {0}; + struct HcfBlob seedBlob = { .data = nullptr, .len = 0 }; // test generate seed ret = randObj->generateRandom(randObj, seedLen, &seedBlob); EXPECT_EQ(ret, HCF_SUCCESS); -- Gitee