merage 12,14,15,16,17,18,19,20,21,22

1.Fix code issue in original code;
2.Update UT/MT source code;
3.Add test code for stability;
4.open alg.DH funtion;
5.Add file lock to backup files;

Signed-off-by: SryLideming <lideming3@huawei.com>

.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "files.associations": {
-        "hks_config.h": "c"
-    }
-}

frameworks/huks_standard/main/common/include/hks_config.h

@@ -93,6 +93,12 @@
 #define HKS_SUPPORT_RSA_ECB_OEAPPADDING
 #define HKS_SUPPORT_RSA_PSS
 
+/* DH */
+#define HKS_SUPPORT_DH_C
+#define HKS_SUPPORT_DH_GENERATE_KEY
+#define HKS_SUPPORT_DH_AGREE_KEY
+#define HKS_SUPPORT_DH_GET_PUBLIC_KEY
+
 /* DSA */
 #define HKS_SUPPORT_DSA_C
 #define HKS_SUPPORT_DSA_GENERATE_KEY

frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c

@@ -80,6 +80,9 @@ static int32_t EncryptCheckParam(const struct HksBlob *key, const struct HksUsag
 int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg,
     struct HksBlob *mac)
 {
+    if (CheckBlob(key) != HKS_SUCCESS || CheckBlob(msg) != HKS_SUCCESS || CheckBlob(mac) != HKS_SUCCESS) {
+        return HKS_ERROR_INVALID_ARGUMENT;
+    }
 #ifdef HKS_SUPPORT_HMAC_C
     return HksMbedtlsHmac(key, digestAlg, msg, mac);
 #else
@@ -235,6 +238,10 @@ int32_t HksCryptoHalDeriveKey(const struct HksBlob *mainKey,
 int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey,
     const struct HksKeySpec *spec, struct HksBlob *sharedKey)
 {
+    if (CheckBlob(nativeKey) != HKS_SUCCESS || CheckBlob(pubKey) != HKS_SUCCESS || spec == NULL ||
+        CheckBlob(sharedKey) != HKS_SUCCESS) {
+        return HKS_ERROR_INVALID_ARGUMENT;
+    }
     switch (spec->algType) {
 #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY)
         case HKS_ALG_ECDH:
@@ -261,6 +268,10 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl
 int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
     const struct HksBlob *message, struct HksBlob *signature)
 {
+    if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS ||
+        CheckBlob(signature) != HKS_SUCCESS) {
+        return HKS_ERROR_INVALID_ARGUMENT;
+    }
     switch (usageSpec->algType) {
 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
         case HKS_ALG_RSA:
@@ -283,6 +294,10 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u
 int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
     const struct HksBlob *message, const struct HksBlob *signature)
 {
+    if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS ||
+        CheckBlob(signature) != HKS_SUCCESS) {
+        return HKS_ERROR_INVALID_ARGUMENT;
+    }
     switch (usageSpec->algType) {
 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
         case HKS_ALG_RSA:

frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c

@@ -246,7 +246,7 @@ static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, const bool needPri
 #endif /* HKS_SUPPORT_RSA_CRYPT or HKS_SUPPORT_RSA_SIGN_VERIFY */
 
 #ifdef HKS_SUPPORT_RSA_CRYPT
-int32_t HksToMbedtlsPadding(uint32_t hksPadding, int32_t *padding)
+static int32_t HksToMbedtlsPadding(uint32_t hksPadding, int32_t *padding)
 {
     switch (hksPadding) {
         case HKS_PADDING_PKCS1_V1_5:
@@ -325,7 +325,7 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec
 #endif /* HKS_SUPPORT_RSA_CRYPT */
 
 #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY
-int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding)
+static int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding)
 {
     switch (hksPadding) {
         case HKS_PADDING_PKCS1_V1_5:

frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c

@@ -192,7 +192,7 @@ int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBl
         return HKS_ERROR_CRYPTO_ENGINE_ERROR;
     }
 
-    if (HKS_KEY_BYTES(spec->keyLen) > DH_size(dh)) {
+    if (HKS_KEY_BYTES(spec->keyLen) > (uint32_t)DH_size(dh)) {
         ret = HKS_ERROR_INVALID_KEY_SIZE;
     } else {
         (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(spec->keyLen));

frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c

@@ -55,6 +55,7 @@ static DSA *InitDsaStruct(const struct HksBlob *key, const bool needPrivateExpon
     BIGNUM *x = NULL;
     if (needPrivateExponent == true) {
         if (keyMaterial->xSize == 0) {
+            DSA_free(dsa);
             return NULL;
         } else {
             (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize);
@@ -199,7 +200,7 @@ static int32_t DsaSaveKeyMaterial(const DSA *dsa, const uint32_t keySize, uint8_
 int32_t HksOpensslDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key)
 {
     int32_t ret;
-    if (spec->keyLen % HKS_BITS_PER_BYTE != 0) {
+    if ((spec->keyLen == 0) || (spec->keyLen % HKS_BITS_PER_BYTE != 0)) {
         return HKS_ERROR_INVALID_ARGUMENT;
     }
 

frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c

@@ -342,7 +342,7 @@ static int32_t GetEvpKey(const struct HksBlob *keyBlob, EVP_PKEY *key, bool priv
     return HKS_SUCCESS;
 }
 
-int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key)
+static int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key)
 {
     int32_t ret = GetEvpKey(nativeKey, key, true);
     if (ret != HKS_SUCCESS) {
@@ -352,7 +352,7 @@ int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key)
     return ret;
 }
 
-int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key)
+static int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key)
 {
     int32_t ret = GetEvpKey(pubKey, key, false);
     if (ret != HKS_SUCCESS) {
@@ -362,7 +362,7 @@ int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key)
     return ret;
 }
 
-int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey)
+static int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey)
 {
     size_t tmpSharedKeySize = (size_t)sharedKey->size;
     if (EVP_PKEY_derive_init(ctx) != 1) {
@@ -378,22 +378,20 @@ int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedK
         return HKS_FAILURE;
     }
 
-    uint8_t *buffer = (uint8_t *)HksMalloc(tmpSharedKeySize);
-    if (buffer == NULL) {
-        HKS_LOG_E("malloc size %u failed", tmpSharedKeySize);
-        return HKS_ERROR_MALLOC_FAIL;
+    if (tmpSharedKeySize > sharedKey->size) {
+        return HKS_ERROR_BUFFER_TOO_SMALL;
     }
-    if (EVP_PKEY_derive(ctx, buffer, &tmpSharedKeySize) != 1) {
+
+    if (EVP_PKEY_derive(ctx, sharedKey->data, &tmpSharedKeySize) != 1) {
         HksLogOpensslError();
-        HksFree(sharedKey->data);
         return HKS_FAILURE;
     }
-    sharedKey->size = (uint32_t)tmpSharedKeySize;
-    sharedKey->data = buffer;
+    sharedKey->size = tmpSharedKeySize;
+    
     return HKS_SUCCESS;
 }
 
-int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey)
+static int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey)
 {
     int32_t res = HKS_FAILURE;
     EVP_PKEY *pKey = EVP_PKEY_new();
@@ -443,6 +441,7 @@ int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubK
     return res;
 }
 
+#ifdef HKS_SUPPORT_ECDH_AGREE_KEY
 int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey,
     const struct HksKeySpec *spec, struct HksBlob *sharedKey)
 {
@@ -458,6 +457,7 @@ int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct Hks
 
     return ret;
 }
+#endif
 
 static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign)
 {

frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c

@@ -331,7 +331,7 @@ static int32_t GetRsaSignPadding(uint32_t padding, uint32_t *rsaPadding)
     }
 }
 
-static EVP_MD_CTX *InitRSAMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing)
+static EVP_MD_CTX *InitRsaMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing)
 {
     int32_t ret = HKS_FAILURE;
     uint32_t opensslPadding = 0;
@@ -397,7 +397,7 @@ static EVP_MD_CTX *InitRSAMdCtx(const struct HksBlob *key, const struct HksUsage
 int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
     const struct HksBlob *message, struct HksBlob *signature)
 {
-    EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, true);
+    EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, true);
     if (ctx == NULL) {
         HKS_LOG_E("initialize rsa md context failed");
         return HKS_ERROR_INVALID_KEY_INFO;
@@ -437,7 +437,7 @@ int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *
 int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
     const struct HksBlob *message, const struct HksBlob *signature)
 {
-    EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, false);
+    EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, false);
     if (ctx == NULL) {
         HKS_LOG_E("initialize rsa md context failed");
         return HKS_ERROR_INVALID_KEY_INFO;

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp

@@ -22,35 +22,79 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalAesKey : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+
+    HksErrorCode generateKeyResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_AES,
+        .keyLen = HKS_AES_KEY_SIZE_128,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_AES,
+        .keyLen = HKS_AES_KEY_SIZE_192,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_AES,
+        .keyLen = HKS_AES_KEY_SIZE_256,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+}  // namespace
+
+class HksCryptoHalAesKey : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob key = { .size = 0, .data = nullptr };
+        ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
+        if (testCaseParams.generateKeyResult == HKS_SUCCESS) {
+            ASSERT_NE((uint32_t)0, key.size);
+            ASSERT_NE(nullptr, key.data);
+            HksFree(key.data);
+        }
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalAesKey_001
  * @tc.name      : HksCryptoHalAesKey_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate AES-128bit key.
  */
-HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_AES,
-        .keyLen = HKS_AES_KEY_SIZE_128,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_AES_KEY_001_PARAMS);
 }
 
 /**
@@ -58,27 +102,9 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalAesKey_002
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate AES-192bit key.
  */
-HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_AES,
-        .keyLen = HKS_AES_KEY_SIZE_192,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_AES_KEY_002_PARAMS);
 }
 
 /**
@@ -86,26 +112,11 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalAesKey_003
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate AES-256bit key.
  */
-HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_AES,
-        .keyLen = HKS_AES_KEY_SIZE_256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_AES_KEY_003_PARAMS);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp

@@ -22,7 +22,10 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
-namespace {
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test {};
 
 /**
@@ -30,7 +33,7 @@ class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test {
  * @tc.name      : HksCryptoHalApiMbedtls_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- key is NULL.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -49,7 +52,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_002
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- algType is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -70,7 +73,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_003
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- algType is AES keyLen is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -91,7 +94,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_004
  * @tc.desc      : Using HksCryptoHalEncrypt -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -126,7 +129,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_005
  * @tc.desc      : Using HksCryptoHalDecrypt -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -160,7 +163,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_006
  * @tc.desc      : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -184,7 +187,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_007
  * @tc.desc      : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -207,7 +210,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_008
  * @tc.desc      : Using HksCryptoHalDecrypt -- AES decrypt padding is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -230,7 +233,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_009
  * @tc.desc      : Using HksCryptoHalDecrypt -- AES decrypt CBC mode nopadding with large iv.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -252,7 +255,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_010
  * @tc.desc      : Using HksCryptoHalDecrypt -- RSA decrypt key is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -297,7 +300,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_011
  * @tc.desc      : Using HksMbedtlsGetRsaPubKey -- RSA in/out key is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -331,7 +334,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_012
  * @tc.desc      : Using HksMbedtlsEccGenerateKey -- key size is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -351,7 +354,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_013
  * @tc.desc      : Using HksMbedtlsGetEccPubKey -- Ecc in/out key is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -395,7 +398,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_014
  * @tc.desc      : Using HksMbedtlsDhGenerateKey -- key size is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -415,7 +418,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_015
  * @tc.desc      : Using HksMbedtlsGetDhPubKey -- Ecc in/out key is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -448,7 +451,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTes
  * @tc.name      : HksCryptoHalApiMbedtls_016
  * @tc.desc      : Using HksMbedtlsDhAgreeKey -- Ecc in/out key is invalid.
  */
-HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -477,4 +480,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTes
     HKS_FREE_BLOB(key);
 }
 #endif
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp

@@ -22,7 +22,10 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
-namespace {
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test {};
 
 /**
@@ -30,7 +33,7 @@ class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test {
  * @tc.name      : HksCryptoHalApiOpenssl_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- key is NULL.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -48,7 +51,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_002
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- algType is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -68,7 +71,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_003
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate key -- keyLen is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -110,7 +113,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_004
  * @tc.desc      : Using HksCryptoHalEncrypt -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -145,7 +148,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_005
  * @tc.desc      : Using HksCryptoHalDecrypt -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -179,7 +182,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_006
  * @tc.desc      : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -215,7 +218,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_007
  * @tc.desc      : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -243,7 +246,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_008
  * @tc.desc      : Using HksCryptoHalDecrypt -- decrypt padding is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -270,7 +273,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_009
  * @tc.desc      : Using HksCryptoHalSign -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level0)
 {
     HksBlob key = { .size = 0, .data = nullptr };
     HksUsageSpec spec = { .algType = 0xffff };
@@ -297,7 +300,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_010
  * @tc.desc      : Using HksCryptoHalVerify -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level0)
 {
     HksBlob key = { .size = 0, .data = nullptr };
     HksUsageSpec spec = { .algType = 0xffff };
@@ -324,7 +327,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_011
  * @tc.desc      : RSA Using HksCryptoHalSign -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level0)
 {
     HksKeySpec spec = {
         .algType = HKS_ALG_RSA,
@@ -352,7 +355,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_012
  * @tc.desc      : RSA Using HksCryptoHalVerify -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level0)
 {
     uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0};
     HksBlob key = { .size = sizeof(buff), .data = buff };
@@ -371,7 +374,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_013
  * @tc.desc      : DSA Using HksCryptoHalSign -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level0)
 {
     HksKeySpec spec = {
         .algType = HKS_ALG_DSA,
@@ -396,7 +399,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_014
  * @tc.desc      : DSA Using HksCryptoHalVerify -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level0)
 {
     uint8_t buff[HKS_KEY_BYTES(256)] = {0};
     HksBlob key = { .size = sizeof(buff), .data = buff };
@@ -412,7 +415,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_015
  * @tc.desc      : ECDSA Using HksCryptoHalSign -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level0)
 {
     uint8_t buff[HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_256)] = {0};
     HksBlob key = { .size = sizeof(buff), .data = buff };
@@ -428,7 +431,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_016
  * @tc.desc      : ECDSA Using HksCryptoHalVerify -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level0)
 {
     HksKeySpec spec = {
         .algType = HKS_ALG_ECC,
@@ -453,7 +456,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_017
  * @tc.desc      : Using HksCryptoHalAgreeKey -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level0)
 {
     HksBlob key = { .size = 0, .data = nullptr };
     HksBlob pubKey = { .size = 0, .data = nullptr };
@@ -480,7 +483,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_018
  * @tc.desc      : ECDH Using HksCryptoHalAgreeKey -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level0)
 {
     HksKeySpec keySpec = {
         .algType = HKS_ALG_ECC,
@@ -509,7 +512,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_019
  * @tc.desc      : DH Using HksCryptoHalAgreeKey -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level0)
 {
     HksKeySpec keySpec = {
         .algType = HKS_ALG_DH,
@@ -539,7 +542,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTes
  * @tc.name      : HksCryptoHalApiOpenssl_020
  * @tc.desc      : Using HksCryptoHalAgreeKey -- parameter is invalid.
  */
-HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level0)
 {
     HksBlob key = { .size = 0, .data = nullptr };
     HksBlob message = { .size = 0, .data = nullptr };
@@ -559,4 +562,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTes
 
     EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#ifdef HKS_SUPPORT_DH_C
 #include <gtest/gtest.h>
 #include <iostream>
 
@@ -22,27 +21,54 @@
 #include "hks_crypto_hal_common.h"
 #include "hks_config.h"
 
+#ifdef HKS_SUPPORT_DH_C
+
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+
+    HksErrorCode generateKeyResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_001_PARAMS = {
+    .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048, },
+    .generateKeyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_002_PARAMS = {
+    .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072, },
+    .generateKeyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_003_PARAMS = {
+    .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096, },
+    .generateKeyResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob key = { 0, NULL };
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
+        HKS_FREE_BLOB(key);
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalDh_001
  * @tc.name      : HksCryptoHalDh_001
  * @tc.desc      : Generate Dh-2048 key pair
  */
-HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048 };
-
-    HksBlob key = { 0, NULL };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-    EXPECT_EQ(HKS_SUCCESS, ret);
-
-    HKS_FREE_BLOB(key);
+    RunTestCase(HKS_CRYPTO_HAL_DH_001_PARAMS);
 }
 
 /**
@@ -50,18 +76,9 @@ HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level1)
  * @tc.name      : HksCryptoHalDh_002
  * @tc.desc      : Generate Dh-3072 key pair
  */
-HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072 };
-
-    HksBlob key = { 0, NULL };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-    EXPECT_EQ(HKS_SUCCESS, ret);
-
-    HKS_FREE_BLOB(key);
+    RunTestCase(HKS_CRYPTO_HAL_DH_002_PARAMS);
 }
 
 /**
@@ -69,18 +86,12 @@ HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level1)
  * @tc.name      : HksCryptoHalDh_003
  * @tc.desc      : Generate Dh-4096 key pair
  */
-HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 };
-
-    HksBlob key = { 0, NULL };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-    EXPECT_EQ(HKS_SUCCESS, ret);
-
-    HKS_FREE_BLOB(key);
+    RunTestCase(HKS_CRYPTO_HAL_DH_003_PARAMS);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS
 #endif

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#ifdef HKS_SUPPORT_DH_C
 #include <gtest/gtest.h>
 #include <iostream>
 
@@ -22,50 +21,94 @@
 #include "hks_crypto_hal_common.h"
 #include "hks_mem.h"
 
+#ifdef HKS_SUPPORT_DH_C
+
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode agreeResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_DH,
+        .keyLen = HKS_DH_KEY_SIZE_2048,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_DH,
+        .keyLen = HKS_DH_KEY_SIZE_3072,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_DH,
+        .keyLen = HKS_DH_KEY_SIZE_4096,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob alise = { .size = 0, .data = nullptr };
+        HksBlob bob = { .size = 0, .data = nullptr };
+
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), HKS_SUCCESS);
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), HKS_SUCCESS);
+
+        struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
+        struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
+
+        EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
+        EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
+
+        struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
+        struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
+
+        EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.spec, &agreeKeyAlise), HKS_SUCCESS);
+        EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.spec, &agreeKeyBob), HKS_SUCCESS);
+
+        EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
+        EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
+
+        HksFree(alise.data);
+        HksFree(bob.data);
+        HksFree(pubKeyAlise.data);
+        HksFree(pubKeyBob.data);
+        HksFree(agreeKeyAlise.data);
+        HksFree(agreeKeyBob.data);
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalDhAgree_001
  * @tc.name      : HksCryptoHalDhAgree_001
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree DH-2048 key.
  */
-HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DH,
-        .keyLen = HKS_DH_KEY_SIZE_2048,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS);
 }
 
 /**
@@ -73,41 +116,9 @@ HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDhAgree_002
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree DH-3072 key.
  */
-HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DH,
-        .keyLen = HKS_DH_KEY_SIZE_3072,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS);
 }
 
 /**
@@ -115,41 +126,12 @@ HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDhAgree_003
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree DH-4096 key.
  */
-HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DH,
-        .keyLen = HKS_DH_KEY_SIZE_4096,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-    struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) };
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS
 #endif

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp

@@ -22,7 +22,10 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
-namespace {
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 class HksCryptoHalDsaKey : public HksCryptoHalCommon, public testing::Test {};
 
 /**
@@ -30,7 +33,7 @@ class HksCryptoHalDsaKey : public HksCryptoHalCommon, public testing::Test {};
  * @tc.name      : HksCryptoHalDsaKey_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate DSA-256bit key.
  */
-HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -64,7 +67,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalDsaKey_002
  * @tc.desc      : Generate key and export public key with DSA.
  */
-HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -100,4 +103,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Leve
     HKS_FREE_BLOB(key);
     HKS_FREE_BLOB(keyOut);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp

@@ -22,61 +22,104 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test {};
+const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC = {
+    .algType = HKS_ALG_DSA,
+    .mode = HKS_MODE_ECB,
+    .padding = HKS_PADDING_NONE,
+    .digest = HKS_DIGEST_SHA1,
+    .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
+};
+
+const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC = {
+    .algType = HKS_ALG_DSA,
+    .mode = HKS_MODE_ECB,
+    .padding = HKS_PADDING_NONE,
+    .digest = HKS_DIGEST_SHA224,
+    .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
+};
+
+const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC = {
+    .algType = HKS_ALG_DSA,
+    .mode = HKS_MODE_ECB,
+    .padding = HKS_PADDING_NONE,
+    .digest = HKS_DIGEST_SHA256,
+    .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
+};
+
+const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC = {
+    .algType = HKS_ALG_DSA,
+    .mode = HKS_MODE_ECB,
+    .padding = HKS_PADDING_NONE,
+    .digest = HKS_DIGEST_SHA384,
+    .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
+};
+
+const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC = {
+    .algType = HKS_ALG_DSA,
+    .mode = HKS_MODE_ECB,
+    .padding = HKS_PADDING_NONE,
+    .digest = HKS_DIGEST_SHA512,
+    .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
+};
+}  // namespace
+
+class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const HksUsageSpec &hksUsageSpec)
+    {
+        HksKeySpec spec = {
+            .algType = HKS_ALG_DSA,
+            .keyLen = 256,
+            .algParam = nullptr,
+        };
+
+        HksBlob key = { .size = 0, .data = nullptr };
+
+#if defined(_USE_MBEDTLS_)
+        EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
+        return;
+#endif
+#if defined(_USE_OPENSSL_)
+        EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
+#endif
+
+        const char *hexData = "00112233445566778899aabbccddeeff";
+        uint32_t dataLen = strlen(hexData) / 2;
+
+        HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
+        for (uint32_t ii = 0; ii < dataLen; ii++) {
+            message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
+        }
+        struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
+
+        EXPECT_EQ(HksCryptoHalSign(&key, &hksUsageSpec, &message, &signature), HKS_SUCCESS);
+
+        struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
+
+        EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
+
+        EXPECT_EQ(HksCryptoHalVerify(&pubKey, &hksUsageSpec, &message, &signature), HKS_SUCCESS);
+
+        HksFree(key.data);
+        HksFree(message.data);
+        HksFree(signature.data);
+        HksFree(pubKey.data);
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalDsaSign_001
  * @tc.name      : HksCryptoHalDsaSign_001
  * @tc.desc      : Using HksCryptoHalSign Sign DSA-SHA1 key.
  */
-HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DSA,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-#if defined(_USE_MBEDTLS_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
-    return;
-#endif
-#if defined(_USE_OPENSSL_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-#endif
-
-    HksUsageSpec usageSpec = {
-        .algType = HKS_ALG_DSA,
-        .mode = HKS_MODE_ECB,
-        .padding = HKS_PADDING_NONE,
-        .digest = HKS_DIGEST_SHA1,
-        .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
-    };
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
-
-    EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    HksFree(key.data);
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(pubKey.data);
+    RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC);
 }
 
 /**
@@ -84,53 +127,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDsaSign_002
  * @tc.desc      : Using HksCryptoHalSign Sign DSA-SHA224 key.
  */
-HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DSA,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-#if defined(_USE_MBEDTLS_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
-    return;
-#endif
-#if defined(_USE_OPENSSL_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-#endif
-
-    HksUsageSpec usageSpec = {
-        .algType = HKS_ALG_DSA,
-        .mode = HKS_MODE_ECB,
-        .padding = HKS_PADDING_NONE,
-        .digest = HKS_DIGEST_SHA224,
-        .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
-    };
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
-
-    EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    HksFree(key.data);
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(pubKey.data);
+    RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC);
 }
 
 /**
@@ -138,53 +137,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDsaSign_003
  * @tc.desc      : Using HksCryptoHalSign Sign DSA-SHA256 key.
  */
-HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DSA,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-#if defined(_USE_MBEDTLS_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
-    return;
-#endif
-#if defined(_USE_OPENSSL_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-#endif
-
-    HksUsageSpec usageSpec = {
-        .algType = HKS_ALG_DSA,
-        .mode = HKS_MODE_ECB,
-        .padding = HKS_PADDING_NONE,
-        .digest = HKS_DIGEST_SHA256,
-        .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
-    };
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
-
-    EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    HksFree(key.data);
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(pubKey.data);
+    RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC);
 }
 
 /**
@@ -192,53 +147,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDsaSign_004
  * @tc.desc      : Using HksCryptoHalSign Sign DSA-SHA384 key.
  */
-HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DSA,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-#if defined(_USE_MBEDTLS_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
-    return;
-#endif
-#if defined(_USE_OPENSSL_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-#endif
-
-    HksUsageSpec usageSpec = {
-        .algType = HKS_ALG_DSA,
-        .mode = HKS_MODE_ECB,
-        .padding = HKS_PADDING_NONE,
-        .digest = HKS_DIGEST_SHA384,
-        .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
-    };
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
-
-    EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    HksFree(key.data);
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(pubKey.data);
+    RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC);
 }
 
 /**
@@ -246,52 +157,11 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Le
  * @tc.name      : HksCryptoHalDsaSign_005
  * @tc.desc      : Using HksCryptoHalSign Sign DSA-SHA512 key.
  */
-HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_DSA,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-#if defined(_USE_MBEDTLS_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED);
-    return;
-#endif
-#if defined(_USE_OPENSSL_)
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-#endif
-
-    HksUsageSpec usageSpec = {
-        .algType = HKS_ALG_DSA,
-        .mode = HKS_MODE_ECB,
-        .padding = HKS_PADDING_NONE,
-        .digest = HKS_DIGEST_SHA512,
-        .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
-    };
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
-
-    EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS);
-
-    HksFree(key.data);
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(pubKey.data);
+    RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp

@@ -22,35 +22,92 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+
+    HksErrorCode generateKeyResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_224,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_256,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_384,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_521,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+}  // namespace
+
+class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob key = { .size = 0, .data = nullptr };
+        ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
+        if (testCaseParams.generateKeyResult == HKS_SUCCESS) {
+            ASSERT_NE((uint32_t)0, key.size);
+            ASSERT_NE(nullptr, key.data);
+            HksFree(key.data);
+        }
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalEccKey_001
  * @tc.name      : HksCryptoHalEccKey_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate ECC-224bit key.
  */
-HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_224,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS);
 }
 
 /**
@@ -58,27 +115,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalEccKey_002
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate ECC-256bit key.
  */
-HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS);
 }
 
 /**
@@ -86,27 +125,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalEccKey_003
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate ECC-384bit key.
  */
-HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_384,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS);
 }
 
 /**
@@ -114,27 +135,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalEccKey_004
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate ECC-521bit key.
  */
-HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level0)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_521,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS);
 }
 
 /**
@@ -142,7 +145,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Leve
  * @tc.name      : HksCryptoHalEccKey_005
  * @tc.desc      : Generate key and export public key with ECC.
  */
-HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -166,4 +169,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Leve
     HKS_FREE_BLOB(key);
     HKS_FREE_BLOB(keyOut);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp

@@ -22,51 +22,124 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+    HksKeySpec specForAgree;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode agreeResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_224,
+        .algParam = nullptr,
+    },
+    .specForAgree = {
+        .algType = HKS_ALG_ECDH,
+        .keyLen = HKS_ECC_KEY_SIZE_224,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_256,
+        .algParam = nullptr,
+    },
+    .specForAgree = {
+        .algType = HKS_ALG_ECDH,
+        .keyLen = HKS_ECC_KEY_SIZE_256,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_384,
+        .algParam = nullptr,
+    },
+    .specForAgree = {
+        .algType = HKS_ALG_ECDH,
+        .keyLen = HKS_ECC_KEY_SIZE_384,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_ECC,
+        .keyLen = HKS_ECC_KEY_SIZE_521,
+        .algParam = nullptr,
+    },
+    .specForAgree = {
+        .algType = HKS_ALG_ECDH,
+        .keyLen = HKS_ECC_KEY_SIZE_521,
+        .algParam = nullptr,
+    },
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob alise = { .size = 0, .data = nullptr };
+        HksBlob bob = { .size = 0, .data = nullptr };
+
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), testCaseParams.generateKeyResult);
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), testCaseParams.generateKeyResult);
+
+        struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
+        struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
+
+        EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
+        EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
+
+        struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
+        struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
+
+        EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.specForAgree, &agreeKeyAlise),
+            testCaseParams.agreeResult);
+        EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.specForAgree, &agreeKeyBob),
+            testCaseParams.agreeResult);
+
+        EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
+        EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
+
+        HksFree(alise.data);
+        HksFree(bob.data);
+        HksFree(pubKeyAlise.data);
+        HksFree(pubKeyBob.data);
+        HksFree(agreeKeyAlise.data);
+        HksFree(agreeKeyBob.data);
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalEcdhAgree_001
  * @tc.name      : HksCryptoHalEcdhAgree_001
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree ECC-224 key.
  */
-HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_224,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    spec.algType = HKS_ALG_ECDH;
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS);
 }
 
 /**
@@ -74,43 +147,9 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest
  * @tc.name      : HksCryptoHalEcdhAgree_002
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree ECC-256 key.
  */
-HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_256,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    spec.algType = HKS_ALG_ECDH;
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS);
 }
 
 /**
@@ -118,43 +157,9 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest
  * @tc.name      : HksCryptoHalEcdhAgree_003
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree ECC-384 key.
  */
-HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_384,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    spec.algType = HKS_ALG_ECDH;
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS);
 }
 
 /**
@@ -162,42 +167,11 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest
  * @tc.name      : HksCryptoHalEcdhAgree_004
  * @tc.desc      : Using HksCryptoHalAgreeKey Agree ECC-521 key.
  */
-HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_ECC,
-        .keyLen = HKS_ECC_KEY_SIZE_521,
-        .algParam = nullptr,
-    };
-
-    HksBlob alise = { .size = 0, .data = nullptr };
-    HksBlob bob = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS);
-
-    struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS);
-
-    struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-    struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) };
-
-    spec.algType = HKS_ALG_ECDH;
-
-    EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS);
-    EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS);
-
-    EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
-    EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
-
-    HksFree(alise.data);
-    HksFree(bob.data);
-    HksFree(pubKeyAlise.data);
-    HksFree(pubKeyBob.data);
-    HksFree(agreeKeyAlise.data);
-    HksFree(agreeKeyBob.data);
+    RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp

@@ -22,40 +22,113 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+    HksKeyDigest digest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode hmacResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_HMAC,
+        .keyLen = 256,
+        .algParam = nullptr,
+    },
+    .digest = HKS_DIGEST_SHA1,
+
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_HMAC,
+        .keyLen = 256,
+        .algParam = nullptr,
+    },
+    .digest = HKS_DIGEST_SHA224,
+
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_HMAC,
+        .keyLen = 256,
+        .algParam = nullptr,
+    },
+    .digest = HKS_DIGEST_SHA256,
+
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_HMAC,
+        .keyLen = 256,
+        .algParam = nullptr,
+    },
+    .digest = HKS_DIGEST_SHA384,
+
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_HMAC,
+        .keyLen = 256,
+        .algParam = nullptr,
+    },
+    .digest = HKS_DIGEST_SHA512,
+
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob key = { .size = 0, .data = nullptr };
+
+        EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
+
+        const char *hexData = "00112233445566778899aabbccddeeff";
+        uint32_t dataLen = strlen(hexData) / 2;
+
+        HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
+        for (uint32_t ii = 0; ii < dataLen; ii++) {
+            message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
+        }
+        struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
+
+        EXPECT_EQ(HksCryptoHalHmac(&key, testCaseParams.digest, &message, &signature), testCaseParams.hmacResult);
+
+        HksFree(message.data);
+        HksFree(signature.data);
+        HksFree(key.data);
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalHmacHmac_001
  * @tc.name      : HksCryptoHalHmacHmac_001
  * @tc.desc      : Using HksCryptoHalHmac HMAC HMAC-256-SHA1 key.
  */
-HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_HMAC,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA1, &message, &signature), HKS_SUCCESS);
-
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(key.data);
+    RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS);
 }
 
 /**
@@ -63,32 +136,9 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest |
  * @tc.name      : HksCryptoHalHmacHmac_002
  * @tc.desc      : Using HksCryptoHalHmac HMAC HMAC-256-SHA224 key.
  */
-HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_HMAC,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA224, &message, &signature), HKS_SUCCESS);
-
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(key.data);
+    RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS);
 }
 
 /**
@@ -96,32 +146,9 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest |
  * @tc.name      : HksCryptoHalHmacHmac_003
  * @tc.desc      : Using HksCryptoHalHmac HMAC HMAC-256-SHA256 key.
  */
-HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_HMAC,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA256, &message, &signature), HKS_SUCCESS);
-
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(key.data);
+    RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS);
 }
 
 /**
@@ -129,32 +156,9 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest |
  * @tc.name      : HksCryptoHalHmacHmac_004
  * @tc.desc      : Using HksCryptoHalHmac HMAC HMAC-256-SHA384 key.
  */
-HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_HMAC,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA384, &message, &signature), HKS_SUCCESS);
-
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(key.data);
+    RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS);
 }
 
 /**
@@ -162,31 +166,11 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest |
  * @tc.name      : HksCryptoHalHmacHmac_005
  * @tc.desc      : Using HksCryptoHalHmac HMAC HMAC-256-SHA512 key.
  */
-HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level0)
 {
-    HksKeySpec spec = {
-        .algType = HKS_ALG_HMAC,
-        .keyLen = 256,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
-
-    const char *hexData = "00112233445566778899aabbccddeeff";
-    uint32_t dataLen = strlen(hexData) / 2;
-
-    HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
-    for (uint32_t ii = 0; ii < dataLen; ii++) {
-        message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]);
-    }
-    struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) };
-
-    EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_SUCCESS);
-
-    HksFree(message.data);
-    HksFree(signature.data);
-    HksFree(key.data);
+    RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp

@@ -22,7 +22,10 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
-namespace {
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 class HksCryptoHalHmacKey : public HksCryptoHalCommon, public testing::Test {};
 
 /**
@@ -30,7 +33,7 @@ class HksCryptoHalHmacKey : public HksCryptoHalCommon, public testing::Test {};
  * @tc.name      : HksCryptoHalHmacKey_001
  * @tc.desc      : Using HksCryptoHalGenerateKey Generate HMAC-256bit key.
  */
-HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Level1)
+HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Level0)
 {
     int32_t ret;
 
@@ -52,4 +55,7 @@ HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Le
     ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
 #endif
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp

@@ -22,8 +22,109 @@
 #include "hks_mem.h"
 
 using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace UnitTest {
 namespace {
-class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test {};
+struct TestCaseParams {
+    HksKeySpec spec;
+
+    HksErrorCode generateKeyResult;
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_512,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_768,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_1024,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_2048,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_3072,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS = {
+    .spec = {
+        .algType = HKS_ALG_RSA,
+        .keyLen = HKS_RSA_KEY_SIZE_4096,
+        .algParam = nullptr,
+    },
+#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
+    .generateKeyResult = HKS_SUCCESS,
+#else
+    .generateKeyResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+}  // namespace
+
+class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        HksBlob key = { .size = 0, .data = nullptr };
+        ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
+        if (testCaseParams.generateKeyResult == HKS_SUCCESS) {
+            ASSERT_NE((uint32_t)0, key.size);
+            ASSERT_NE(nullptr, key.data);
+            HksFree(key.data);
+        }
+    }
+};
 
 /**
  * @tc.number    : HksCryptoHalRsaKey_001
@@ -32,25 +133,7 @@ class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test {};
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_512,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS);
 }
 
 /**
@@ -60,25 +143,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Leve
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_768,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS);
 }
 
 /**
@@ -88,25 +153,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Leve
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_1024,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS);
 }
 
 /**
@@ -116,25 +163,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Leve
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_2048,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS);
 }
 
 /**
@@ -144,25 +173,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Leve
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_3072,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS);
 }
 
 /**
@@ -172,25 +183,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Leve
  */
 HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_006, Function | SmallTest | Level1)
 {
-    int32_t ret;
-
-    HksKeySpec spec = {
-        .algType = HKS_ALG_RSA,
-        .keyLen = HKS_RSA_KEY_SIZE_4096,
-        .algParam = nullptr,
-    };
-
-    HksBlob key = { .size = 0, .data = nullptr };
-
-    ret = HksCryptoHalGenerateKey(&spec, &key);
-#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY)
-    ASSERT_EQ(HKS_SUCCESS, ret);
-    ASSERT_NE((uint32_t)0, key.size);
-    ASSERT_NE(nullptr, key.data);
-    HksFree(key.data);
-#else
-    ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret);
-#endif
+    RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS);
 }
 
 /**
@@ -222,4 +215,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_007, Function | SmallTest | Leve
     HKS_FREE_BLOB(key);
     HKS_FREE_BLOB(keyOut);
 }
-}  // namespace
+}  // namespace UnitTest
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn

@@ -19,22 +19,17 @@ module_output_path = "huks_standard/huks_standard_test"
 ohos_moduletest("huks_mt_test") {
   module_out_path = module_output_path
   sources = [
-    "src/hks_aes_cipher_mt_test.cpp",
-    "src/hks_aes_decrypt_mt_test.cpp",
-    "src/hks_aes_encrypt_mt_test.cpp",
-    "src/hks_aes_key_mt_test.cpp",
-    "src/hks_agree_mt_test.cpp",
-    "src/hks_dsa_test_mt.cpp",
-    "src/hks_ecc_key_mt_test.cpp",
-    "src/hks_ecc_sign_mt_test.cpp",
-    "src/hks_ecc_verify_mt_test.cpp",
-    "src/hks_hmac_mt_test.cpp",
-    "src/hks_openssl_aes_test_mt.c",
-    "src/hks_openssl_dh_mt_test.c",
-    "src/hks_openssl_dsa_sign_test_mt.c",
-    "src/hks_openssl_ecc_mt_test.c",
-    "src/hks_openssl_hmac_mt_test.c",
-    "src/hks_openssl_rsa_test_mt.c",
+    "src/hks_aes_cipher_mt.cpp",
+    "src/hks_aes_decrypt_mt.cpp",
+    "src/hks_aes_encrypt_mt.cpp",
+    "src/hks_aes_key_mt.cpp",
+    "src/hks_agree_mt.cpp",
+    "src/hks_dsa_mt.cpp",
+    "src/hks_ecc_key_mt.cpp",
+    "src/hks_ecc_sign_mt.cpp",
+    "src/hks_ecc_verify_mt.cpp",
+    "src/hks_hmac_mt.cpp",
+    "src/hks_rsa_common_mt.cpp",
     "src/hks_rsa_ecb_nopadding_mt.cpp",
     "src/hks_rsa_ecb_oaep_padding_mt.cpp",
     "src/hks_rsa_ecb_oaep_sha1_mt.cpp",
@@ -55,6 +50,12 @@ ohos_moduletest("huks_mt_test") {
     "src/hks_rsa_sha384_with_rsa_pss_mt.cpp",
     "src/hks_rsa_sha512_with_rsa_mt.cpp",
     "src/hks_rsa_sha512_with_rsa_pss_mt.cpp",
+    "src/openssl_aes_helper.c",
+    "src/openssl_dh_helper.c",
+    "src/openssl_dsa_helper.c",
+    "src/openssl_ecc_helper.c",
+    "src/openssl_hmac_helper.c",
+    "src/openssl_rsa_helper.c",
   ]
 
   if (use_crypto_lib == "openssl") {

interfaces/innerkits/huks_standard/test/moduletest/include/hks_rsa_common_mt.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HKS_RSA_COMMON_MT_H
+#define HKS_RSA_COMMON_MT_H
+
+#include <string>
+#include <vector>
+
+#include "hks_type.h"
+#include "hks_param.h"
+
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+#define BIT_NUM_OF_UINT8 8
+
+struct GenerateKeyCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+struct EncryptLocalCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+struct EncryptServiceCaseParams {
+    std::string alias;
+    std::vector<HksParam> params;
+    std::string hexData;
+    int padding;
+    HksKeyDigest keyDigest;
+    uint32_t keySize;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+struct DecryptLocalCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+struct DecryptServiceCaseParams {
+    std::string alias;
+    std::vector<HksParam> params;
+    std::string hexData;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+struct SignLocalCaseParams {
+    std::vector<HksParam> params;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode signResult;
+    HksErrorCode verifyResult;
+};
+
+struct SignServiceCaseParams {
+    std::string alias;
+    std::vector<HksParam> params;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode signResult;
+    HksErrorCode verifyResult;
+};
+
+struct VerifyLocalCaseParams {
+    std::vector<HksParam> params;
+    int padding;
+    HksKeyDigest keyDigest;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode signResult;
+    HksErrorCode verifyResult;
+};
+
+struct VerifyServiceCaseParams {
+    std::string alias;
+    std::vector<HksParam> params;
+    int padding;
+    HksKeyDigest keyDigest;
+    uint32_t keySize;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode signResult;
+    HksErrorCode verifyResult;
+};
+
+class HksRsaCommonMt {
+protected:
+    void GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams);
+
+    void EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams);
+
+    void EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams);
+
+    void DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams);
+
+    void DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams);
+
+    void SignLocalTestCase(const SignLocalCaseParams &testCaseParams);
+
+    void SignServiceTestCase(const SignServiceCaseParams &testCaseParams);
+
+    void VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams);
+
+    void VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams);
+};
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS
+#endif

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_RSA_TEST_MT_H
-#define HKS_OPENSSL_RSA_TEST_MT_H
+#ifndef OPENSSL_AES_HELPER_H
+#define OPENSSL_AES_HELPER_H
 
 #include <securec.h>
 
@@ -28,24 +28,23 @@ extern "C" {
 #endif
 
 #define AAD_SIZE 16
-#define AES_FAILED ((uint32_t)1)
-#define AES_SUCCESS ((uint32_t)0)
 #define COMPLEMENT_LEN 16
 #define IV_SIZE 16
 #define OUT_PARAMSET_SIZE 2048
+#define AUTHID_KEY_SIZE 256
 
 int32_t GenerateAesKey(const int key_len, struct HksBlob *randomKey);
 
-uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey);
 
-uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey);
 
-uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey, const struct HksBlob *tagAead);
 
-uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey, const struct HksBlob *tagDec);
 
 #ifdef __cplusplus

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_DH_TEST_MT_H
-#define HKS_OPENSSL_DH_TEST_MT_H
+#ifndef OPENSSL_DH_HELPER_H
+#define OPENSSL_DH_HELPER_H
 
 #include <stdbool.h>
 
@@ -32,7 +32,6 @@ extern "C" {
 
 #define DH_FAILED 1
 #define DH_SUCCESS 0
-#define DH_KEY_SIZE 2048
 
 int32_t DhGenerateKey(const int keyLen, struct HksBlob *key);
 

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_DSA_SIGN_TEST_MT_H
-#define HKS_OPENSSL_DSA_SIGN_TEST_MT_H
+#ifndef OPENSSL_DSA_SIGN_MT_HELPER_H
+#define OPENSSL_DSA_SIGN_MT_HELPER_H
 
 #include <securec.h>
 

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_ECC_TEST_MT_H
-#define HKS_OPENSSL_ECC_TEST_MT_H
+#ifndef OPENSSL_ECC_HELPER_H
+#define OPENSSL_ECC_HELPER_H
 
 #include <stdbool.h>
 

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_HMAC_TEST_MT_H
-#define HKS_OPENSSL_HMAC_TEST_MT_H
+#ifndef OPENSSL_HMAC_HELPER_H
+#define OPENSSL_HMAC_HELPER_H
 
 #include <stdbool.h>
 

interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef HKS_OPENSSL_RSA_TEST_MT_H
-#define HKS_OPENSSL_RSA_TEST_MT_H
+#ifndef OPENSSL_RSA_MT_HELPER_H
+#define OPENSSL_RSA_MT_HELPER_H
 
 #include <securec.h>
 
@@ -29,7 +29,7 @@ extern "C" {
 #endif
 
 #define BIT_NUM_OF_UINT8 8
-#define RSA_FAILED 1
+#define RSA_FAILED (-1)
 #define RSA_SUCCESS 0
 
 void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key);

interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp

@@ -0,0 +1,662 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_aes_helper.h"
+
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    uint32_t inLenAppend = 0;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+const uint8_t IV[IV_SIZE] = {0};
+const uint8_t AAD_DATA[AAD_SIZE] = {0};
+const char TEST_AES_KEY[] = "This is a AES key";
+
+const TestCaseParams HUKS_AES_CIPER_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_CIPER_MT_01800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksAesCipherMt : public testing::Test {
+protected:
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY };
+
+        struct HksParamSet *paramInSet = nullptr;
+        HksInitParamSet(&paramInSet);
+
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult);
+
+        HksBlob plainText = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+
+        uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN;
+        HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(cipherText.data, nullptr);
+        EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult);
+        if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) {
+            HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+            ASSERT_NE(plainTextDecrypt.data, nullptr);
+            EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult);
+            EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length());
+            EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0);
+            HksFree(plainTextDecrypt.data);
+        }
+
+        HksFree(cipherText.data);
+        HksFreeParamSet(&paramInSet);
+    }
+};
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00100
+ * @tc.name      : HksAesCipherMt00100
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00200
+ * @tc.name      : HksAesCipherMt00200
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00300
+ * @tc.name      : HksAesCipherMt00300
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00400
+ * @tc.name      : HksAesCipherMt00400
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00500
+ * @tc.name      : HksAesCipherMt00500
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00600
+ * @tc.name      : HksAesCipherMt00600
+ * @tc.desc      : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00700
+ * @tc.name      : HksAesCipherMt00700
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00800
+ * @tc.name      : HksAesCipherMt00800
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt00900
+ * @tc.name      : HksAesCipherMt00900
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_00900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01000
+ * @tc.name      : HksAesCipherMt01000
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01100
+ * @tc.name      : HksAesCipherMt01100
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01200
+ * @tc.name      : HksAesCipherMt01200
+ * @tc.desc      : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01300
+ * @tc.name      : HksAesCipherMt01300
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01400
+ * @tc.name      : HksAesCipherMt01400
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01500
+ * @tc.name      : HksAesCipherMt01500
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01600
+ * @tc.name      : HksAesCipherMt01600
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01700
+ * @tc.name      : HksAesCipherMt01700
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesCipherMt.HksAesCipherMt01800
+ * @tc.name      : HksAesCipherMt01800
+ * @tc.desc      : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesCipherMt, HksAesCipherMt01800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_CIPER_MT_01800_PARAMS);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp

@@ -0,0 +1,686 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_aes_helper.h"
+
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    uint32_t inLenAppend = 0;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+const uint8_t IV[IV_SIZE] = {0};
+const uint8_t AAD_DATA[AAD_SIZE] = {0};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_DECRYPT_MT_01800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksAesDecryptMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) };
+
+        struct HksParamSet *paramInSet = nullptr;
+        HksInitParamSet(&paramInSet);
+
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE);
+        uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE);
+
+        EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult);
+
+        HksBlob plainText = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+
+        uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN;
+        HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(cipherText.data, nullptr);
+        HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(plainTextDecrypt.data, nullptr);
+        if (blockMode == HKS_MODE_GCM) {
+            HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) };
+            EXPECT_EQ(
+                AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), testCaseParams.encryptResult);
+            cipherText.size += AAD_SIZE;
+            (void)memcpy_s(cipherText.data + AAD_SIZE, AAD_SIZE, tagAead.data, AAD_SIZE);
+            HksFree(tagAead.data);
+        } else {
+            EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), testCaseParams.encryptResult);
+        }
+        EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult);
+        if (testCaseParams.decryptResult != HKS_ERROR_NOT_SUPPORTED) {
+            EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length());
+            EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0);
+        }
+
+        HksFree(authId.data);
+        HksFree(cipherText.data);
+        HksFree(plainTextDecrypt.data);
+        HksFreeParamSet(&paramInSet);
+    }
+};
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00100
+ * @tc.name      : HksAesDecryptMt00100
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00200
+ * @tc.name      : HksAesDecryptMt00200
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00300
+ * @tc.name      : HksAesDecryptMt00300
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00400
+ * @tc.name      : HksAesDecryptMt00400
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00500
+ * @tc.name      : HksAesDecryptMt00500
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00600
+ * @tc.name      : HksAesDecryptMt00600
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00700
+ * @tc.name      : HksAesDecryptMt00700
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00800
+ * @tc.name      : HksAesDecryptMt00800
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt00900
+ * @tc.name      : HksAesDecryptMt00900
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_00900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01000
+ * @tc.name      : HksAesDecryptMt01000
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01100
+ * @tc.name      : HksAesDecryptMt01100
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01200
+ * @tc.name      : HksAesDecryptMt01200
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01300
+ * @tc.name      : HksAesDecryptMt01300
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01400
+ * @tc.name      : HksAesDecryptMt01400
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01500
+ * @tc.name      : HksAesDecryptMt01500
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01500_PARAMS);
+}
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01600
+ * @tc.name      : HksAesDecryptMt01600
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01700
+ * @tc.name      : HksAesDecryptMt01700
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesDecryptMt.HksAesDecryptMt01800
+ * @tc.name      : HksAesDecryptMt01800
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using
+ * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_DECRYPT_MT_01800_PARAMS);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp

@@ -0,0 +1,682 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_aes_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    uint32_t inLenAppend = 0;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+const uint8_t IV[IV_SIZE] = {0};
+const uint8_t AAD_DATA[AAD_SIZE] = {0};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+#if defined(_USE_OPENSSL_)
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+#endif
+#if defined(_USE_MBEDTLS_)
+    .encryptResult = HKS_ERROR_NOT_SUPPORTED,
+#endif
+};
+
+const TestCaseParams HUKS_AES_ENCRYPT_MT_01800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksAesEncryptMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) };
+
+        struct HksParamSet *paramInSet = NULL;
+        HksInitParamSet(&paramInSet);
+
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE);
+        uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE);
+
+        EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult);
+
+        HksBlob plainText = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+
+        uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN;
+        HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(cipherText.data, nullptr);
+        HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(plainTextDecrypt.data, nullptr);
+        EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult);
+        if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) {
+            if (blockMode == HKS_MODE_GCM) {
+                HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) };
+                (void)memcpy_s(tagAead.data, AAD_SIZE, cipherText.data + AAD_SIZE, AAD_SIZE);
+                cipherText.size = AAD_SIZE;
+                EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead),
+                    testCaseParams.decryptResult);
+                HksFree(tagAead.data);
+            } else {
+                EXPECT_EQ(
+                    AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), testCaseParams.decryptResult);
+            }
+            EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length());
+            EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0);
+        }
+
+        HksFree(authId.data);
+        HksFree(cipherText.data);
+        HksFree(plainTextDecrypt.data);
+        HksFreeParamSet(&paramInSet);
+    }
+};
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00100
+ * @tc.name      : HksAesEncryptMt00100
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00200
+ * @tc.name      : HksAesEncryptMt00200
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00300
+ * @tc.name      : HksAesEncryptMt00300
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00400
+ * @tc.name      : HksAesEncryptMt00400
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00500
+ * @tc.name      : HksAesEncryptMt00500
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00600
+ * @tc.name      : HksAesEncryptMt00600
+ * @tc.desc      : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using
+ * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00700
+ * @tc.name      : HksAesEncryptMt00700
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00800
+ * @tc.name      : HksAesEncryptMt00800
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt00900
+ * @tc.name      : HksAesEncryptMt00900
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_00900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01000
+ * @tc.name      : HksAesEncryptMt01000
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01100
+ * @tc.name      : HksAesEncryptMt01100
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01200
+ * @tc.name      : HksAesEncryptMt01200
+ * @tc.desc      : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using
+ * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01300
+ * @tc.name      : HksAesEncryptMt01300
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01400
+ * @tc.name      : HksAesEncryptMt01400
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01500
+ * @tc.name      : HksAesEncryptMt01500
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01600
+ * @tc.name      : HksAesEncryptMt01600
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01700
+ * @tc.name      : HksAesEncryptMt01700
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesEncryptMt.HksAesEncryptMt01800
+ * @tc.name      : HksAesEncryptMt01800
+ * @tc.desc      : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using
+ * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_ENCRYPT_MT_01800_PARAMS);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp

@@ -0,0 +1,678 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_aes_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+    uint32_t inLenAppend = 0;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode encryptResult;
+    HksErrorCode decryptResult;
+};
+
+const uint8_t IV[IV_SIZE] = {0};
+const uint8_t AAD_DATA[AAD_SIZE] = {0};
+const char TEST_AES_KEY[] = "This is a AES key";
+
+const TestCaseParams HUKS_AES_KEY_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = COMPLEMENT_LEN,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
+        { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AES_KEY_MT_01800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+        { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM },
+        { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } },
+        { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } },
+    },
+    .hexData = "0123456789abcdef",
+    .inLenAppend = 0,
+    .generateKeyResult = HKS_SUCCESS,
+    .encryptResult = HKS_SUCCESS,
+    .decryptResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksAesKeyMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY };
+
+        struct HksParamSet *paramInSet = NULL;
+        HksInitParamSet(&paramInSet);
+
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE);
+
+        struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(OUT_PARAMSET_SIZE);
+        ASSERT_NE(paramSetOut, nullptr);
+        (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE);
+        paramSetOut->paramSetSize = OUT_PARAMSET_SIZE;
+
+        EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), testCaseParams.generateKeyResult);
+
+        HksParam *symmetricParam = NULL;
+        HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam);
+        HksBlob symmetricKey = { .size = symmetricParam->blob.size,
+            .data = (uint8_t *)HksMalloc(symmetricParam->blob.size) };
+        (void)memcpy_s(
+            symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size);
+
+        HksBlob plainText = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+
+        uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN;
+        HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(cipherText.data, nullptr);
+        HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+        ASSERT_NE(plainTextDecrypt.data, nullptr);
+        if (blockMode == HKS_MODE_GCM) {
+            HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) };
+            EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead),
+                testCaseParams.encryptResult);
+            EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead),
+                testCaseParams.decryptResult);
+            HksFree(tagAead.data);
+        } else {
+            EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), testCaseParams.encryptResult);
+            EXPECT_EQ(
+                AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), testCaseParams.decryptResult);
+        }
+        EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length());
+        EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0);
+
+        HksFree(paramSetOut);
+        HksFree(symmetricKey.data);
+        HksFree(cipherText.data);
+        HksFree(plainTextDecrypt.data);
+        HksFreeParamSet(&paramInSet);
+    }
+};
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00100
+ * @tc.name      : HksAesKeyMt00100
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00200
+ * @tc.name      : HksAesKeyMt00200
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00300
+ * @tc.name      : HksAesKeyMt00300
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00400
+ * @tc.name      : HksAesKeyMt00400
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00500
+ * @tc.name      : HksAesKeyMt00500
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00600
+ * @tc.name      : HksAesKeyMt00600
+ * @tc.desc      : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00700
+ * @tc.name      : HksAesKeyMt00700
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00800
+ * @tc.name      : HksAesKeyMt00800
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt00900
+ * @tc.name      : HksAesKeyMt00900
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_00900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01000
+ * @tc.name      : HksAesKeyMt01000
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01100
+ * @tc.name      : HksAesKeyMt01100
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01200
+ * @tc.name      : HksAesKeyMt01200
+ * @tc.desc      : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01300
+ * @tc.name      : HksAesKeyMt01300
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01400
+ * @tc.name      : HksAesKeyMt01400
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CBC/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01500
+ * @tc.name      : HksAesKeyMt01500
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/CTR/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01600
+ * @tc.name      : HksAesKeyMt01600
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01600, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01700
+ * @tc.name      : HksAesKeyMt01700
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/ECB/pkcs7padding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01700, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksAesKeyMt.HksAesKeyMt01800
+ * @tc.name      : HksAesKeyMt01800
+ * @tc.desc      : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using
+ * AES/GCM/nopadding algorithm
+ */
+HWTEST_F(HksAesKeyMt, HksAesKeyMt01800, TestSize.Level0)
+{
+    RunTestCase(HUKS_AES_KEY_MT_01800_PARAMS);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp

@@ -0,0 +1,908 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_ecc_helper.h"
+#include "openssl_dh_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_config.h"
+#include "hks_mem.h"
+#include "hks_param.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> generateKeyParams;
+    std::vector<HksParam> agreeKeyParams;
+    std::string hexData;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode agreeResult;
+};
+
+const char ALISE_KEY[] = "This is a alise key";
+const char BOB_KEY[] = "This is a bob key";
+const uint32_t KEY_MEMORY = 4096;
+
+int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn,
+    struct HksBlob *priKey, struct HksBlob *pubKey)
+{
+    struct HksParamSet *paramOutSet = NULL;
+    HksInitParamSet(&paramOutSet);
+    if (keyLen == 0) {
+        return HKS_FAILURE;
+    }
+
+    uint8_t *localData = (uint8_t *)HksMalloc(keyLen);
+    if (localData == NULL) {
+        return HKS_FAILURE;
+    }
+    struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = { .size = keyLen, .data = localData } };
+    HksAddParams(paramOutSet, &localKey, 1);
+    HksBuildParamSet(&paramOutSet);
+
+    if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) {
+        return HKS_FAILURE;
+    }
+
+    HksParam *priParam = NULL;
+    HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam);
+    priKey->size = priParam->blob.size;
+    (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size);
+
+    HksParam *pubParam = NULL;
+    HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam);
+    pubKey->size = pubParam->blob.size;
+    (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size);
+
+    HksFree(localData);
+    HksFreeParamSet(&paramOutSet);
+    return HKS_SUCCESS;
+}
+
+const TestCaseParams HUKS_AGREE_MT_00100_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00200_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00300_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00400_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00500_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00600_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00700_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00800_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_00900_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01000_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01100_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01200_PARAMS = {
+    .generateKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+#ifdef HKS_SUPPORT_DH_C
+const TestCaseParams HUKS_AGREE_MT_01300_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01400_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01500_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01600_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01700_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01800_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_01900_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_02000_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_AGREE_MT_02100_PARAMS = {
+    .agreeKeyParams = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .agreeResult = HKS_SUCCESS,
+};
+#endif
+}  // namespace
+
+class HksAgreeMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void ServiceAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams,
+        struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob)
+    {
+        struct HksParamSet *agreeKeyParams = NULL;
+        HksInitParamSet(&agreeKeyParams);
+        HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size());
+        HksBuildParamSet(&agreeKeyParams);
+#ifdef HKS_SUPPORT_DH_C
+        uint32_t algorithm = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_ALGORITHM);
+#endif
+        uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE);
+        struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY };
+
+        HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+
+        EXPECT_EQ(HksGenerateKey(&bob, generateKeyParams, NULL), testCaseParams.generateKeyResult);
+
+        HksBlob x509KeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        HksBlob x509KeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        EXPECT_EQ(HksExportPublicKey(&bob, generateKeyParams, &x509KeyBob), HKS_SUCCESS);
+#ifdef HKS_SUPPORT_DH_C
+        if (algorithm == HKS_ALG_ECDH) {
+#endif
+            EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult);
+            EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS);
+            EXPECT_EQ(EcdhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult);
+
+            EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS);
+            EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS);
+#ifdef HKS_SUPPORT_DH_C
+        } else if (algorithm == HKS_ALG_DH) {
+            EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult);
+            EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS);
+            EXPECT_EQ(DhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult);
+
+            EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS);
+            EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS);
+        }
+#endif
+
+        EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &x509KeyAlise, agreeKeyBob), testCaseParams.agreeResult);
+
+        HksFree(alise.data);
+        HksFree(x509KeyAlise.data);
+        HksFree(x509KeyBob.data);
+        HksFree(pubKeyAlise.data);
+        HksFree(pubKeyBob.data);
+        HksFreeParamSet(&agreeKeyParams);
+    }
+
+    void LocalAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams,
+        struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob, int32_t scenario)
+    {
+        struct HksParamSet *agreeKeyParams = NULL;
+        HksInitParamSet(&agreeKeyParams);
+        HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size());
+        HksBuildParamSet(&agreeKeyParams);
+        uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE);
+        HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        if (scenario == 0) {
+            struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY };
+            struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY };
+            HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            EXPECT_EQ(LocalHksGenerate(keySize, &alise, generateKeyParams, &priKeyAlise, &pubKeyAlise),
+                testCaseParams.generateKeyResult);
+            EXPECT_EQ(LocalHksGenerate(keySize, &bob, generateKeyParams, &priKeyBob, &pubKeyBob),
+                testCaseParams.generateKeyResult);
+            EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult);
+            EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult);
+            HksFree(priKeyAlise.data);
+            HksFree(priKeyBob.data);
+        } else if (scenario == 1) {
+            struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult);
+            EXPECT_EQ(ECCGenerateKey(keySize, &bob), testCaseParams.generateKeyResult);
+            EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS);
+            EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS);
+            EXPECT_EQ(HksAgreeKey(agreeKeyParams, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult);
+            EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult);
+            HksFree(alise.data);
+            HksFree(bob.data);
+        }
+        HksFreeParamSet(&agreeKeyParams);
+        HksFree(pubKeyAlise.data);
+        HksFree(pubKeyBob.data);
+    }
+
+    void EcdhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario)
+    {
+        struct HksParamSet *generateKeyParams = NULL;
+        HksInitParamSet(&generateKeyParams);
+        HksAddParams(
+            generateKeyParams, testCaseParams.generateKeyParams.data(), testCaseParams.generateKeyParams.size());
+        HksBuildParamSet(&generateKeyParams);
+
+        uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG);
+
+        HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+
+        if (storage == HKS_STORAGE_TEMP) {
+            LocalAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob, scenario);
+        } else if (storage == HKS_STORAGE_PERSISTENT) {
+            ServiceAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob);
+        }
+        EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
+        EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
+
+        HksFreeParamSet(&generateKeyParams);
+        HksFree(agreeKeyAlise.data);
+        HksFree(agreeKeyBob.data);
+    }
+
+#ifdef HKS_SUPPORT_DH_C
+    void DhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario)
+    {
+        struct HksParamSet *paramInSet = NULL;
+        HksInitParamSet(&paramInSet);
+        HksAddParams(paramInSet, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE);
+        uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG);
+
+        HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+        HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+
+        if (storage == HKS_STORAGE_TEMP) {
+            HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+            if (scenario == 0) {
+                struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY };
+                struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY };
+                HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+                HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+                EXPECT_EQ(LocalHksGenerate(keySize, &alise, paramInSet, &priKeyAlise, &pubKeyAlise),
+                    testCaseParams.generateKeyResult);
+                EXPECT_EQ(LocalHksGenerate(keySize, &bob, paramInSet, &priKeyBob, &pubKeyBob),
+                    testCaseParams.generateKeyResult);
+                EXPECT_EQ(DhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult);
+                EXPECT_EQ(DhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult);
+                HksFree(priKeyAlise.data);
+                HksFree(priKeyBob.data);
+            } else if (scenario == 1) {
+                struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+                struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) };
+                EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult);
+                EXPECT_EQ(DhGenerateKey(keySize, &bob), testCaseParams.generateKeyResult);
+                EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS);
+                EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS);
+                EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult);
+                EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult);
+                HksFree(alise.data);
+                HksFree(bob.data);
+            }
+            HksFree(pubKeyAlise.data);
+            HksFree(pubKeyBob.data);
+        } else if (storage == HKS_STORAGE_PERSISTENT) {
+            ServiceAgreeScenario(testCaseParams, paramInSet, &agreeKeyAlise, &agreeKeyBob);
+        }
+        EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size);
+        EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS);
+
+        HksFreeParamSet(&paramInSet);
+        HksFree(agreeKeyAlise.data);
+        HksFree(agreeKeyBob.data);
+    }
+#endif
+};
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00100
+ * @tc.name      : HksAgreeMt00100
+ * @tc.desc      : Both parties use huks to generate an ecc224 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00100, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00100_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00200
+ * @tc.name      : HksAgreeMt00200
+ * @tc.desc      : Both parties use huks to generate an ecc256 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00200, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00200_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00300
+ * @tc.name      : HksAgreeMt00300
+ * @tc.desc      : Both parties use huks to generate an ecc384 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00300, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00300_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00400
+ * @tc.name      : HksAgreeMt00400
+ * @tc.desc      : Both parties use huks to generate an ecc521 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00400, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00400_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00500
+ * @tc.name      : HksAgreeMt00500
+ * @tc.desc      : Both parties use OpenSSL to generate an ecc224 bit key, which can be successfully used in huks to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00500, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00500_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00600
+ * @tc.name      : HksAgreeMt00600
+ * @tc.desc      : Both parties use OpenSSL to generate an ecc256 bit key, which can be successfully used in huks to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00600, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00600_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00700
+ * @tc.name      : HksAgreeMt00700
+ * @tc.desc      : Both parties use OpenSSL to generate an ecc384 bit key, which can be successfully used in huks to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00700, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00700_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00800
+ * @tc.name      : HksAgreeMt00800
+ * @tc.desc      : Both parties use OpenSSL to generate an ecc521 bit key, which can be successfully used in huks to
+ * negotiate using the ECDH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00800, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00800_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt00900
+ * @tc.name      : HksAgreeMt00900
+ * @tc.desc      : One party uses the key of ECC224 for openssl negotiation, and the other party uses the key of ECC224
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt00900, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_00900_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01000
+ * @tc.name      : HksAgreeMt01000
+ * @tc.desc      : One party uses the key of ECC256 for openssl negotiation, and the other party uses the key of ECC256
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01000, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_01000_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01100
+ * @tc.name      : HksAgreeMt01100
+ * @tc.desc      : One party uses the key of ECC384 for openssl negotiation, and the other party uses the key of ECC384
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01100, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_01100_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01200
+ * @tc.name      : HksAgreeMt01200
+ * @tc.desc      : One party uses the key of ECC521 for openssl negotiation, and the other party uses the key of ECC521
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01200, TestSize.Level0)
+{
+    EcdhRunTestCase(HUKS_AGREE_MT_01200_PARAMS, 0);
+}
+
+#ifdef HKS_SUPPORT_DH_C
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01300
+ * @tc.name      : HksAgreeMt01300
+ * @tc.desc      : Both parties use huks to generate an dh2048 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01300, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01300_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01400
+ * @tc.name      : HksAgreeMt01400
+ * @tc.desc      : Both parties use huks to generate an dh3072 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01400, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01400_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01500
+ * @tc.name      : HksAgreeMt01500
+ * @tc.desc      : Both parties use huks to generate an dh4096 bit key, which can be successfully used in OpenSSL to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01500, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01500_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01600
+ * @tc.name      : HksAgreeMt01600
+ * @tc.desc      : Both parties use OpenSSL to generate an dh2048 bit key, which can be successfully used in huks to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01600, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01600_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01700
+ * @tc.name      : HksAgreeMt01700
+ * @tc.desc      : Both parties use OpenSSL to generate an dh3072 bit key, which can be successfully used in huks to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01700, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01700_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01800
+ * @tc.name      : HksAgreeMt01800
+ * @tc.desc      : Both parties use OpenSSL to generate an dh4096 bit key, which can be successfully used in huks to
+ * negotiate using the DH algorithm
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01800, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01800_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt01900
+ * @tc.name      : HksAgreeMt01900
+ * @tc.desc      : One party uses the key of dh2048 for openssl negotiation, and the other party uses the key of dh2048
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt01900, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_01900_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt02000
+ * @tc.name      : HksAgreeMt02000
+ * @tc.desc      : One party uses the key of dh3072 for openssl negotiation, and the other party uses the key of dh2048
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt02000, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_02000_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksAgreeMt.HksAgreeMt02100
+ * @tc.name      : HksAgreeMt02100
+ * @tc.desc      : One party uses the key of dh4096 for openssl negotiation, and the other party uses the key of dh2048
+ * for huks negotiation
+ */
+HWTEST_F(HksAgreeMt, HksAgreeMt02100, TestSize.Level0)
+{
+    DhRunTestCase(HUKS_AGREE_MT_02100_PARAMS, 0);
+}
+#endif
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp

@@ -0,0 +1,753 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_ecc_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+#include "hks_param.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode signResult;
+    HksErrorCode verifyResult;
+};
+
+const char ECC_KEY[] = "This is a ECC key";
+
+const TestCaseParams HUKS_ECC_KEY_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_01900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_02000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_02100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_02200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_02300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_ECC_KEY_MT_02400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .signResult = HKS_SUCCESS,
+    .verifyResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksEccKeyMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void RunTestCase(const TestCaseParams &testCaseParams)
+    {
+        struct HksBlob authId = { (uint32_t)strlen(ECC_KEY), (uint8_t *)ECC_KEY };
+
+        struct HksParamSet *paramInSet = NULL;
+        HksInitParamSet(&paramInSet);
+
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST);
+
+        struct HksParamSet *paramOutSet = NULL;
+        HksInitParamSet(&paramOutSet);
+        struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
+            .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_521) } };
+        HksAddParams(paramOutSet, &localKey, 1);
+
+        HksBuildParamSet(&paramOutSet);
+
+        EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult);
+        HksParam *priParam = NULL;
+        HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam);
+        HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)HksMalloc(priParam->blob.size) };
+        (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size);
+
+        HksParam *pubParam = NULL;
+        HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam);
+        HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)HksMalloc(pubParam->blob.size) };
+        (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size);
+
+        HksBlob message = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+        HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) };
+
+        EXPECT_EQ(EcdsaSign(&priKey, digest, &message, &signature), testCaseParams.signResult);
+        EXPECT_EQ(EcdsaVerify(&pubKey, digest, &message, &signature), testCaseParams.verifyResult);
+
+        HksFreeParamSet(&paramInSet);
+        HksFree(localKey.blob.data);
+        HksFreeParamSet(&paramOutSet);
+        HksFree(priKey.data);
+        HksFree(pubKey.data);
+        HksFree(signature.data);
+    }
+};
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00100
+ * @tc.name      : HksEccKeyMt00100
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-NONE algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00200
+ * @tc.name      : HksEccKeyMt00200
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA1 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00300
+ * @tc.name      : HksEccKeyMt00300
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA224 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00400
+ * @tc.name      : HksEccKeyMt00400
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA256 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00500
+ * @tc.name      : HksEccKeyMt00500
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA384 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00600
+ * @tc.name      : HksEccKeyMt00600
+ * @tc.desc      : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA512 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00700
+ * @tc.name      : HksEccKeyMt00700
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-NONE algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00800
+ * @tc.name      : HksEccKeyMt00800
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA1 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt00900
+ * @tc.name      : HksEccKeyMt00900
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA224 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_00900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01000
+ * @tc.name      : HksEccKeyMt01000
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA256 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01100
+ * @tc.name      : HksEccKeyMt01100
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA384 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01200
+ * @tc.name      : HksEccKeyMt01200
+ * @tc.desc      : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA512 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01300
+ * @tc.name      : HksEccKeyMt01300
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-NONE algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01400
+ * @tc.name      : HksEccKeyMt01400
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA1 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01400_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01500
+ * @tc.name      : HksEccKeyMt01500
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA224 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01500_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01600
+ * @tc.name      : HksEccKeyMt01600
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA256 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01600, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01600_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01700
+ * @tc.name      : HksEccKeyMt01700
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA384 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01700, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01700_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01800
+ * @tc.name      : HksEccKeyMt01800
+ * @tc.desc      : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA512 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01800, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01800_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt01900
+ * @tc.name      : HksEccKeyMt01900
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-NONE algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt01900, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_01900_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt02000
+ * @tc.name      : HksEccKeyMt02000
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA1 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt02000, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_02000_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt02100
+ * @tc.name      : HksEccKeyMt02100
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA224 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt02100, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_02100_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt02200
+ * @tc.name      : HksEccKeyMt02200
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA256 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt02200, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_02200_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt02300
+ * @tc.name      : HksEccKeyMt02300
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA384 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt02300, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_02300_PARAMS);
+}
+
+/**
+ * @tc.number    : HksEccKeyMt.HksEccKeyMt02400
+ * @tc.name      : HksEccKeyMt02400
+ * @tc.desc      : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using
+ * ECC/DIGEST-SHA512 algorithm
+ */
+HWTEST_F(HksEccKeyMt, HksEccKeyMt02400, TestSize.Level0)
+{
+    RunTestCase(HUKS_ECC_KEY_MT_02400_PARAMS);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp

@@ -0,0 +1,489 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "openssl_hmac_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+#include "hks_param.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+struct TestCaseParams {
+    std::vector<HksParam> params;
+    std::string hexData;
+
+    HksErrorCode generateKeyResult;
+    HksErrorCode hmacResult;
+};
+
+const char HMAC_KEY[] = "This is a HMAC key";
+
+const TestCaseParams HUKS_HMAC_MT_00100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00600_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00700_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00800_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_00900_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01000_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01100_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01200_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01300_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01400_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+
+const TestCaseParams HUKS_HMAC_MT_01500_PARAMS = {
+    .params = {
+        { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
+        { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
+        { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE },
+        { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
+        { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 },
+        { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
+        { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
+    },
+    .hexData = "0123456789abcdef",
+    .generateKeyResult = HKS_SUCCESS,
+    .hmacResult = HKS_SUCCESS,
+};
+}  // namespace
+
+class HksHmacMt : public testing::Test {
+protected:
+    uint32_t ReadValueByTag(std::vector<HksParam> params, uint32_t needTag)
+    {
+        for (auto testParams : params) {
+            if (testParams.tag == needTag) {
+                return testParams.uint32Param;
+            }
+        }
+        return 0;
+    }
+
+    void RunTestCase(const TestCaseParams &testCaseParams, int32_t scenario)
+    {
+        struct HksBlob authId = { (uint32_t)strlen(HMAC_KEY), (uint8_t *)HMAC_KEY };
+
+        struct HksParamSet *paramInSet = NULL;
+        HksInitParamSet(&paramInSet);
+        HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size());
+        HksBuildParamSet(&paramInSet);
+
+        uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST);
+        uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG);
+
+        HksBlob message = {
+            .size = (uint32_t)testCaseParams.hexData.length(),
+            .data = (uint8_t *)&testCaseParams.hexData[0],
+        };
+        HksBlob macForHuks = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) };
+
+        if (storage == HKS_STORAGE_TEMP) {
+            struct HksParamSet *paramOutSet = NULL;
+            HksInitParamSet(&paramOutSet);
+            struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
+                .blob = { .size = HMAC_KEY_SIZE, .data = (uint8_t *)HksMalloc(HMAC_KEY_SIZE) } };
+            HksAddParams(paramOutSet, &localKey, 1);
+            HksBuildParamSet(&paramOutSet);
+            if (scenario == 0) {
+                EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult);
+            } else if (scenario == 1) {
+                EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), testCaseParams.generateKeyResult);
+            }
+
+            HksParam *outParam = NULL;
+            HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
+            HksBlob key = { .size = outParam->blob.size, .data = (uint8_t *)HksMalloc(outParam->blob.size) };
+            (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
+            HksBlob macMessage = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) };
+
+            EXPECT_EQ(HmacHmac(&key, digest, &message, &macMessage), testCaseParams.hmacResult);
+            EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), testCaseParams.hmacResult);
+
+            EXPECT_EQ(macMessage.size, macForHuks.size);
+            EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
+            if (scenario == 1) {
+                HksFree(authId.data);
+            }
+            HksFreeParamSet(&paramOutSet);
+            HksFree(localKey.blob.data);
+            HksFree(macMessage.data);
+            HksFree(key.data);
+        } else if (storage == HKS_STORAGE_PERSISTENT) {
+            EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult);
+            EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), testCaseParams.hmacResult);
+        }
+
+        HksFreeParamSet(&paramInSet);
+        HksFree(macForHuks.data);
+    }
+};
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00100
+ * @tc.name      : HksHmacMt00100
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00100, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00100_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00200
+ * @tc.name      : HksHmacMt00200
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00200, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00200_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00300
+ * @tc.name      : HksHmacMt00300
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00300, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00300_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00400
+ * @tc.name      : HksHmacMt00400
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00400, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00400_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00500
+ * @tc.name      : HksHmacMt00500
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00500, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00500_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00600
+ * @tc.name      : HksHmacMt00600
+ * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00600, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00600_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00700
+ * @tc.name      : HksHmacMt00700
+ * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00700, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00700_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00800
+ * @tc.name      : HksHmacMt00800
+ * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00800, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00800_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt00900
+ * @tc.name      : HksHmacMt00900
+ * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt00900, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_00900_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01000
+ * @tc.name      : HksHmacMt01000
+ * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01000, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01000_PARAMS, 1);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01100
+ * @tc.name      : HksHmacMt01100
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01100, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01100_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01200
+ * @tc.name      : HksHmacMt01200
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01200, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01200_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01300
+ * @tc.name      : HksHmacMt01300
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01300, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01300_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01400
+ * @tc.name      : HksHmacMt01400
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01400, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01400_PARAMS, 0);
+}
+
+/**
+ * @tc.number    : HksHmacMt.HksHmacMt01500
+ * @tc.name      : HksHmacMt01500
+ * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation
+ */
+HWTEST_F(HksHmacMt, HksHmacMt01500, TestSize.Level0)
+{
+    RunTestCase(HUKS_HMAC_MT_01500_PARAMS, 0);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp

@@ -1,740 +0,0 @@
-/*
- * Copyright (C) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "hks_openssl_hmac_mt_test.h"
-
-#include <gtest/gtest.h>
-
-#include "hks_api.h"
-#include "hks_mem.h"
-#include "hks_param.h"
-
-using namespace testing::ext;
-namespace {
-namespace {
-const char HMAC_KEY[] = "This is a HMAC key";
-}  // namespace
-class HksHmacMtTest : public testing::Test {};
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00100
- * @tc.name      : HksHmacMtTest00100
- * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00100, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-    struct HksParamSet *paramOutSet = NULL;
-    HksInitParamSet(&paramOutSet);
-    struct HksParam localKey = {
-        .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}};
-    HksAddParams(paramOutSet, &localKey, 1);
-
-    HksBuildParamSet(&paramOutSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS);
-
-    HksParam *outParam = NULL;
-    HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
-
-    HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)};
-    (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
-
-    EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    HksFreeParamSet(&paramOutSet);
-    free(localKey.blob.data);
-    free(macMessage.data);
-    free(macForHuks.data);
-    free(key.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00200
- * @tc.name      : HksHmacMtTest00200
- * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00200, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-    struct HksParamSet *paramOutSet = NULL;
-    HksInitParamSet(&paramOutSet);
-    struct HksParam localKey = {
-        .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}};
-    HksAddParams(paramOutSet, &localKey, 1);
-
-    HksBuildParamSet(&paramOutSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS);
-
-    HksParam *outParam = NULL;
-    HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
-
-    HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)};
-    (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
-
-    EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    HksFreeParamSet(&paramOutSet);
-    free(localKey.blob.data);
-    free(macMessage.data);
-    free(macForHuks.data);
-    free(key.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00300
- * @tc.name      : HksHmacMtTest00300
- * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00300, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-    struct HksParamSet *paramOutSet = NULL;
-    HksInitParamSet(&paramOutSet);
-    struct HksParam localKey = {
-        .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}};
-    HksAddParams(paramOutSet, &localKey, 1);
-
-    HksBuildParamSet(&paramOutSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS);
-
-    HksParam *outParam = NULL;
-    HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
-
-    HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)};
-    (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
-
-    EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    HksFreeParamSet(&paramOutSet);
-    free(localKey.blob.data);
-    free(macMessage.data);
-    free(macForHuks.data);
-    free(key.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00400
- * @tc.name      : HksHmacMtTest00400
- * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00400, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-    struct HksParamSet *paramOutSet = NULL;
-    HksInitParamSet(&paramOutSet);
-    struct HksParam localKey = {
-        .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}};
-    HksAddParams(paramOutSet, &localKey, 1);
-
-    HksBuildParamSet(&paramOutSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS);
-
-    HksParam *outParam = NULL;
-    HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
-
-    HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)};
-    (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
-
-    EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    HksFreeParamSet(&paramOutSet);
-    free(localKey.blob.data);
-    free(macMessage.data);
-    free(macForHuks.data);
-    free(key.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00500
- * @tc.name      : HksHmacMtTest00500
- * @tc.desc      : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00500, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-    struct HksParamSet *paramOutSet = NULL;
-    HksInitParamSet(&paramOutSet);
-    struct HksParam localKey = {
-        .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}};
-    HksAddParams(paramOutSet, &localKey, 1);
-
-    HksBuildParamSet(&paramOutSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS);
-
-    HksParam *outParam = NULL;
-    HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam);
-
-    HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)};
-    (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size);
-
-    EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    HksFreeParamSet(&paramOutSet);
-    free(localKey.blob.data);
-    free(macMessage.data);
-    free(macForHuks.data);
-    free(key.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00600
- * @tc.name      : HksHmacMtTest00600
- * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00600, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS);
-
-    EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macMessage.data);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00700
- * @tc.name      : HksHmacMtTest00700
- * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00700, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS);
-
-    EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macMessage.data);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00800
- * @tc.name      : HksHmacMtTest00800
- * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00800, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS);
-
-    EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macMessage.data);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest00900
- * @tc.name      : HksHmacMtTest00900
- * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest00900, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS);
-
-    EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macMessage.data);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01000
- * @tc.name      : HksHmacMtTest01000
- * @tc.desc      : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01000, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS);
-
-    EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS);
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    EXPECT_EQ(macMessage.size, macForHuks.size);
-    EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macMessage.data);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01100
- * @tc.name      : HksHmacMtTest01100
- * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01100, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
-
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01200
- * @tc.name      : HksHmacMtTest01200
- * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01200, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
-
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01300
- * @tc.name      : HksHmacMtTest01300
- * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01300, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
-
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01400
- * @tc.name      : HksHmacMtTest01400
- * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01400, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
-
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macForHuks.data);
-}
-
-/**
- * @tc.number    : HksHmacMtTest.HksHmacMtTest01500
- * @tc.name      : HksHmacMtTest01500
- * @tc.desc      : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation
- */
-HWTEST_F(HksHmacMtTest, HksHmacMtTest01500, TestSize.Level1)
-{
-    struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY};
-
-    struct HksParamSet *paramInSet = NULL;
-    HksInitParamSet(&paramInSet);
-
-    struct HksParam tmpParams[] = {
-        {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT},
-        {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC},
-        {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE},
-        {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC},
-        {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512},
-        {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true},
-        {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT},
-    };
-
-    HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
-    HksBuildParamSet(&paramInSet);
-
-    const char *hexData = "0123456789abcdef";
-    uint32_t dataLen = strlen(hexData);
-    HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData};
-    HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)};
-
-    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
-
-    EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS);
-
-    HksFreeParamSet(&paramInSet);
-    free(macForHuks.data);
-}
-}  // namespace

interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp

@@ -0,0 +1,522 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hks_rsa_common_mt.h"
+#include "openssl_rsa_helper.h"
+
+#include <gtest/gtest.h>
+
+#include "hks_api.h"
+#include "hks_mem.h"
+
+using namespace testing::ext;
+namespace OHOS {
+namespace Security {
+namespace Huks {
+namespace MT {
+namespace {
+const int SET_SIZE_4096 = 4096;
+}
+
+void HksRsaCommonMt::GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams)
+{
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+    EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult);
+
+    HksParam *pubKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS);
+    HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) };
+    ASSERT_NE(publicKey.data, nullptr);
+    (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size);
+
+    HksParam *priKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS);
+    HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) };
+    ASSERT_NE(privateKey.data, nullptr);
+    (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size);
+
+    HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(),
+        .data = (uint8_t *)&testCaseParams.hexData[0] };
+
+    HksParam *cipherLenBit = NULL;
+    HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit);
+    uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8;
+    HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) };
+    ASSERT_NE(cipherText.data, nullptr);
+
+    EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest),
+        testCaseParams.encryptResult);
+
+    if (testCaseParams.encryptResult == HKS_SUCCESS) {
+        HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+        ASSERT_NE(decryptedText.data, nullptr);
+
+        EXPECT_EQ(
+            DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest),
+            testCaseParams.decryptResult);
+        EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0);
+
+        HksFree(decryptedText.data);
+    }
+
+    HksFree(publicKey.data);
+    HksFree(privateKey.data);
+    HksFree(paramSetOut);
+    HksFree(cipherText.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams)
+{
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS);
+
+    HksParam *pubKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS);
+
+    HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) };
+    ASSERT_NE(publicKey.data, nullptr);
+    (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size);
+
+    HksParam *priKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS);
+
+    HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) };
+    ASSERT_NE(privateKey.data, nullptr);
+    (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size);
+
+    HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(),
+        .data = (uint8_t *)&testCaseParams.hexData[0] };
+
+    HksParam *cipherLenBit = NULL;
+    HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit);
+    uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8;
+    HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) };
+    ASSERT_NE(cipherText.data, nullptr);
+
+    EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult);
+
+    if (testCaseParams.encryptResult == HKS_SUCCESS) {
+        HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+        ASSERT_NE(decryptedText.data, nullptr);
+
+        EXPECT_EQ(
+            DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest),
+            testCaseParams.decryptResult);
+
+        EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0);
+
+        HksFree(decryptedText.data);
+    }
+    HksFree(paramSetOut);
+    HksFree(publicKey.data);
+    HksFree(privateKey.data);
+    HksFree(cipherText.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams)
+{
+    struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(),
+        .data = (uint8_t *)&testCaseParams.alias[0] };
+
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(),
+        .data = (uint8_t *)&testCaseParams.hexData[0] };
+
+    HksParam *cipherLenBit = NULL;
+    HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit);
+    uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8;
+    HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
+    ASSERT_NE(cipherText.data, nullptr);
+
+    struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(opensslRsaKeyInfo.data, nullptr);
+
+    struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+
+    EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize);
+    ASSERT_NE(pkey, nullptr);
+
+    OpensslGetx509PubKey(pkey, &x509Key);
+
+    EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS);
+
+    SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo);
+
+    EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult);
+    if (testCaseParams.encryptResult == HKS_SUCCESS) {
+        HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+        ASSERT_NE(decryptedText.data, nullptr);
+
+        EXPECT_EQ(
+            DecryptRSA(
+                &cipherText, &decryptedText, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest),
+            testCaseParams.decryptResult);
+
+        EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0);
+
+        HksFree(decryptedText.data);
+    }
+
+    EVP_PKEY_free(pkey);
+    HksFree(cipherText.data);
+    HksFree(x509Key.data);
+    HksFree(opensslRsaKeyInfo.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams)
+{
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS);
+
+    HksParam *pubKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS);
+
+    HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) };
+    ASSERT_NE(publicKey.data, nullptr);
+    (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size);
+
+    HksParam *priKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS);
+
+    HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) };
+    ASSERT_NE(privateKey.data, nullptr);
+    (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size);
+
+    HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(),
+        .data = (uint8_t *)&testCaseParams.hexData[0] };
+
+    HksParam *cipherLenBit = NULL;
+    HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit);
+    uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8;
+    HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) };
+    ASSERT_NE(cipherText.data, nullptr);
+
+    EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest),
+        testCaseParams.encryptResult);
+
+    if (testCaseParams.encryptResult == HKS_SUCCESS) {
+        HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+        ASSERT_NE(decryptedText.data, nullptr);
+        EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult);
+        if (testCaseParams.decryptResult == HKS_SUCCESS) {
+            EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0);
+        }
+        HksFree(decryptedText.data);
+    }
+    HksFree(paramSetOut);
+    HksFree(publicKey.data);
+    HksFree(privateKey.data);
+    HksFree(cipherText.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams)
+{
+    struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(),
+        .data = (uint8_t *)&testCaseParams.alias[0] };
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS);
+    uint8_t opensslRsaKey[SET_SIZE_4096] = {0};
+    uint32_t opensslRsaKeyLen = SET_SIZE_4096;
+    struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey };
+    EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS);
+
+    uint8_t rsaPublicKey[SET_SIZE_4096] = {0};
+    uint32_t rsaPublicKeyLen = SET_SIZE_4096;
+    struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey };
+    EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0);
+    HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) };
+    (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size);
+
+    HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(),
+        .data = (uint8_t *)&testCaseParams.hexData[0] };
+    HksParam *cipherLenBit = NULL;
+    HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit);
+    uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8;
+    HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) };
+    ASSERT_NE(cipherText.data, nullptr);
+    EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest),
+        testCaseParams.encryptResult);
+
+    if (testCaseParams.encryptResult == HKS_SUCCESS) {
+        HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+        ASSERT_NE(decryptedText.data, nullptr);
+        EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult);
+
+        if (testCaseParams.decryptResult == HKS_SUCCESS) {
+            EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0);
+        }
+        HksFree(decryptedText.data);
+    }
+
+    HksFree(paramSetOut);
+    HksFree(publicKey.data);
+    HksFree(cipherText.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::SignLocalTestCase(const SignLocalCaseParams &testCaseParams)
+{
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS);
+
+    HksParam *priKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS);
+
+    HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) };
+    ASSERT_NE(privateKey.data, nullptr);
+    (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size);
+
+    const char *hexData = "00112233445566778899aabbccddeeff";
+
+    HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData };
+
+    HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(signData.data, nullptr);
+
+    EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), testCaseParams.signResult);
+    if (testCaseParams.signResult == HKS_SUCCESS) {
+        HksParam *pubKeyExport = NULL;
+        EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS);
+
+        HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) };
+        ASSERT_NE(publicKey.data, nullptr);
+        (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size);
+
+        EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest),
+            testCaseParams.verifyResult);
+        HksFree(publicKey.data);
+    }
+
+    HksFree(paramSetOut);
+    HksFree(privateKey.data);
+    HksFree(signData.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::SignServiceTestCase(const SignServiceCaseParams &testCaseParams)
+{
+    struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(),
+        .data = (uint8_t *)&testCaseParams.alias[0] };
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS);
+
+    const char *hexData = "00112233445566778899aabbccddeeff";
+
+    HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData };
+
+    HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(signData.data, nullptr);
+
+    EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), testCaseParams.signResult);
+    if (testCaseParams.signResult == HKS_SUCCESS) {
+        uint8_t opensslRsaKey[SET_SIZE_4096] = {0};
+        uint32_t opensslRsaKeyLen = SET_SIZE_4096;
+        struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey };
+        EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS);
+
+        uint8_t rsaPublicKey[SET_SIZE_4096] = {0};
+        uint32_t rsaPublicKeyLen = SET_SIZE_4096;
+        struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey };
+        EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0);
+
+        HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) };
+        (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size);
+
+        EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest),
+            testCaseParams.verifyResult);
+        HksFree(publicKey.data);
+    }
+    HksFree(paramSetOut);
+    HksFree(signData.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams)
+{
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096);
+    ASSERT_NE(paramSetOut, nullptr);
+    (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096);
+    paramSetOut->paramSetSize = SET_SIZE_4096;
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS);
+
+    HksParam *priKeyExport = NULL;
+    EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS);
+
+    HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) };
+    ASSERT_NE(privateKey.data, nullptr);
+    (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size);
+
+    const char *hexData = "00112233445566778899aabbccddeeff";
+
+    HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData };
+
+    HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(signData.data, nullptr);
+
+    EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, testCaseParams.padding, testCaseParams.keyDigest),
+        testCaseParams.signResult);
+    if (testCaseParams.signResult == HKS_SUCCESS) {
+        HksParam *pubKeyExport = NULL;
+        EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS);
+
+        HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) };
+        ASSERT_NE(publicKey.data, nullptr);
+        (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size);
+        EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), testCaseParams.verifyResult);
+        HksFree(publicKey.data);
+    }
+    HksFree(paramSetOut);
+    HksFree(privateKey.data);
+    HksFree(signData.data);
+    HksFreeParamSet(&paramInSet);
+}
+
+void HksRsaCommonMt::VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams)
+{
+    struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(),
+        .data = (uint8_t *)&testCaseParams.alias[0] };
+
+    struct HksParamSet *paramInSet = NULL;
+    HksInitParamSet(&paramInSet);
+    ASSERT_NE(paramInSet, nullptr);
+
+    EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS);
+
+    EXPECT_EQ(HksBuildParamSet(&paramInSet), HKS_SUCCESS);
+
+    const char *hexData = "00112233445566778899aabbccddeeff";
+
+    HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData };
+
+    HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(signData.data, nullptr);
+
+    struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+    ASSERT_NE(opensslRsaKeyInfo.data, nullptr);
+
+    struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) };
+
+    EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize);
+    ASSERT_NE(pkey, nullptr);
+
+    OpensslGetx509PubKey(pkey, &x509Key);
+
+    EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS);
+
+    SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo);
+    EXPECT_EQ(
+        OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest),
+        testCaseParams.signResult);
+    if (testCaseParams.signResult == HKS_SUCCESS) {
+        EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), testCaseParams.verifyResult);
+    }
+    EVP_PKEY_free(pkey);
+    HksFree(signData.data);
+    HksFree(x509Key.data);
+    HksFree(opensslRsaKeyInfo.data);
+    HksFreeParamSet(&paramInSet);
+}
+}  // namespace MT
+}  // namespace Huks
+}  // namespace Security
+}  // namespace OHOS

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_aes_test_mt.h"
+#include "openssl_aes_helper.h"
 
 #include <openssl/evp.h>
 
@@ -25,14 +25,19 @@ int32_t GenerateAesKey(const int keyLen, struct HksBlob *randomKey)
     uint32_t keySize = keyLen / BIT_NUM_OF_UINT8;
     uint8_t *Key = (uint8_t *)malloc(keySize);
     do {
-        if (RAND_bytes(Key, keySize) <= 0) {
-            return AES_FAILED;
+        if (RAND_bytes(Key, keySize) != 1) {
+            free(Key);
+            return HKS_FAILURE;
         }
-        randomKey->data = Key;
         randomKey->size = keySize;
+        if (memcpy_s(randomKey->data, randomKey->size, Key, keySize) != 0) {
+            free(Key);
+            return HKS_FAILURE;
+        }
     } while (0);
 
-    return AES_SUCCESS;
+    free(Key);
+    return HKS_SUCCESS;
 }
 
 static const EVP_CIPHER *AesCBCCrypt(uint32_t keyLen)
@@ -97,13 +102,12 @@ static uint32_t AesInit(EVP_CIPHER_CTX **ctx, const EVP_CIPHER **ciper, uint32_t
 
     *ctx = EVP_CIPHER_CTX_new();
     if (*ctx == NULL) {
-        EVP_CIPHER_CTX_free(*ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
-    return AES_SUCCESS;
+    return HKS_SUCCESS;
 }
 
-uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey)
 {
     struct HksParam *mode = NULL;
@@ -117,19 +121,19 @@ uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *
 
     const EVP_CIPHER *ciper = NULL;
     EVP_CIPHER_CTX *ctx = NULL;
-    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) {
+    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     int ret = 1;
@@ -146,19 +150,19 @@ uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *
     int outLen = 0;
     if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size = outLen;
     if (EVP_EncryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size += outLen;
     EVP_CIPHER_CTX_free(ctx);
-    return AES_SUCCESS;
+    return HKS_SUCCESS;
 }
 
-uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey)
 {
     struct HksParam *mode = NULL;
@@ -172,19 +176,19 @@ uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *
 
     const EVP_CIPHER *ciper = NULL;
     EVP_CIPHER_CTX *ctx = NULL;
-    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) {
+    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     int ret = 1;
@@ -201,19 +205,19 @@ uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *
     int outLen = 0;
     if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size = outLen;
     if (EVP_DecryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size += outLen;
     EVP_CIPHER_CTX_free(ctx);
-    return AES_SUCCESS;
+    return HKS_SUCCESS;
 }
 
-uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey, const struct HksBlob *tagAead)
 {
     struct HksParam *mode = NULL;
@@ -227,49 +231,49 @@ uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlo
 
     const EVP_CIPHER *ciper = NULL;
     EVP_CIPHER_CTX *ctx = NULL;
-    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) {
+    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     int outLen = 0;
     if (EVP_EncryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size = outLen;
     if (EVP_EncryptFinal_ex(ctx, outData->data, &outLen) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, HKS_AE_TAG_LEN, tagAead->data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     EVP_CIPHER_CTX_free(ctx);
-    return AES_SUCCESS;
+    return HKS_SUCCESS;
 }
 
-uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
+int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData,
     const struct HksBlob *randomKey, const struct HksBlob *tagDec)
 {
     struct HksParam *mode = NULL;
@@ -283,45 +287,45 @@ uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlo
 
     const EVP_CIPHER *ciper = NULL;
     EVP_CIPHER_CTX *ctx = NULL;
-    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) {
+    if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
 
     int outLen = 0;
     if (EVP_DecryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     outData->size = outLen;
 
     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tagDec->size, tagDec->data) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     if (EVP_DecryptFinal_ex(ctx, outData->data, &outLen) != 1) {
         EVP_CIPHER_CTX_free(ctx);
-        return AES_FAILED;
+        return HKS_FAILURE;
     }
     EVP_CIPHER_CTX_free(ctx);
-    return AES_SUCCESS;
+    return HKS_SUCCESS;
 }

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_dh_mt_test.h"
+#include "openssl_dh_helper.h"
 
 #include <openssl/dh.h>
 #include <openssl/evp.h>
@@ -64,8 +64,12 @@ static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct Hk
     offset += keyMaterial->priKeySize;
 
     key->size = rawMaterialLen;
-    key->data = rawMaterial;
+    if (memcpy_s(key->data, key->size, rawMaterial, rawMaterialLen) != 0) {
+        free(rawMaterial);
+        return DH_FAILED;
+    }
 
+    free(rawMaterial);
     return DH_SUCCESS;
 }
 
@@ -119,6 +123,12 @@ static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponen
     BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL);
 
     if (DH_set0_key(dh, pubKey, privKey) != 1) {
+        if (pubKey != NULL) {
+            BN_free(pubKey);
+        }
+        if (privKey != NULL) {
+            BN_free(privKey);
+        }
         DH_free(dh);
         return NULL;
     }
@@ -130,19 +140,20 @@ int32_t DhAgreeKey(
     const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey)
 {
     int32_t ret;
+
     if ((uint32_t)HKS_KEY_BYTES(keyLen) > sharedKey->size) {
         return DH_FAILED;
     }
 
+    DH *dh = InitDhStruct(nativeKey, true);
+    if (dh == NULL) {
+        return DH_FAILED;
+    }
+
     struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data;
     BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL);
     if (pub == NULL) {
-        return DH_FAILED;
-    }
-
-    DH *dh = InitDhStruct(nativeKey, true);
-    if (dh == NULL) {
-        BN_free(pub);
+        DH_free(dh);
         return DH_FAILED;
     }
 
@@ -200,6 +211,7 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey
 
     DH *dh = EVP_PKEY_get0_DH(pkey);
     if (dh == NULL) {
+        EVP_PKEY_free(pkey);
         return DH_FAILED;
     }
 
@@ -208,6 +220,7 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey
 
     uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + dhpubKeySize);
     if (keyBuffer == NULL) {
+        EVP_PKEY_free(pkey);
         return DH_FAILED;
     }
     struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer;
@@ -219,24 +232,22 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey
 
     BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh));
 
-    publicKey->size = dhpubKeySize;
-    publicKey->data = keyBuffer;
+    publicKey->size = sizeof(struct KeyMaterialDh) + dhpubKeySize;
+    if (memcpy_s(publicKey->data, publicKey->size, keyBuffer, sizeof(struct KeyMaterialDh) + dhpubKeySize) != 0) {
+        EVP_PKEY_free(pkey);
+        free(keyBuffer);
+        return DH_FAILED;
+    }
 
-    SELF_FREE_PTR(pkey, EVP_PKEY_free);
+    free(keyBuffer);
+    EVP_PKEY_free(pkey);
     return DH_SUCCESS;
 }
 
 int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key)
 {
-    struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)key->data;
-    BIGNUM *pub = BN_bin2bn(key->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL);
-    if (pub == NULL) {
-        return DH_FAILED;
-    }
-
     DH *dh = InitDhStruct(key, true);
     if (dh == NULL) {
-        BN_free(pub);
         return DH_FAILED;
     }
     EVP_PKEY *pkey = EVP_PKEY_new();
@@ -245,7 +256,7 @@ int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key)
         return DH_FAILED;
     }
 
-    if (EVP_PKEY_assign_DH(pkey, dh) <= 0) {
+    if (EVP_PKEY_assign_DH(pkey, dh) != 1) {
         DH_free(dh);
         EVP_PKEY_free(pkey);
         return DH_FAILED;
@@ -254,6 +265,17 @@ int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key)
     uint8_t *tmp = NULL;
     int32_t length = i2d_PUBKEY(pkey, &tmp);
     x509Key->size = length;
-    x509Key->data = tmp;
+    if (tmp == NULL) {
+        EVP_PKEY_free(pkey);
+        return DH_FAILED;
+    }
+    if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) {
+        EVP_PKEY_free(pkey);
+        free(tmp);
+        return DH_FAILED;
+    }
+
+    EVP_PKEY_free(pkey);
+    free(tmp);
     return DH_SUCCESS;
 }

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_dsa_sign_test_mt.h"
+#include "openssl_dsa_helper.h"
 
 #include <openssl/evp.h>
 #include <openssl/x509.h>
@@ -27,70 +27,103 @@
 
 EVP_PKEY *GenerateDsaKey(const uint32_t keySize)
 {
-    EVP_PKEY *pkey = EVP_PKEY_new();
-    if (pkey == NULL) {
-        return NULL;
-    }
     DSA *dsa = DSA_new();
     if (dsa == NULL) {
-        EVP_PKEY_free(pkey);
         return NULL;
     }
     if (DSA_generate_parameters_ex(dsa, keySize, NULL, 0, NULL, NULL, NULL) != 1) {
-        EVP_PKEY_free(pkey);
         DSA_free(dsa);
         return NULL;
     }
     if (DSA_generate_key(dsa) != 1) {
+        DSA_free(dsa);
+        return NULL;
+    }
+
+    EVP_PKEY *pkey = EVP_PKEY_new();
+    if (pkey == NULL) {
+        DSA_free(dsa);
+        return NULL;
+    }
+
+    if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) {
         EVP_PKEY_free(pkey);
         DSA_free(dsa);
         return NULL;
     }
 
-    EVP_PKEY_assign_DSA(pkey, dsa);
-
     return pkey;
 }
 
+static BIGNUM *BinToBN(uint8_t *data, uint32_t length)
+{
+    uint8_t buff[length];
+    if (memcpy_s(buff, sizeof(buff), data, length) != 0) {
+        return NULL;
+    }
+    return BN_bin2bn(buff, length, NULL);
+}
+
+static void FreeBN(BIGNUM *bn)
+{
+    if (bn != NULL) {
+        BN_free(bn);
+    }
+}
+
 static DSA *InitDsa(struct HksBlob *key, const bool needPrivateExponent)
 {
     const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data);
-    uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)];
 
     uint32_t offset = sizeof(*keyMaterial);
     BIGNUM *x = NULL;
+    BIGNUM *y = NULL;
+    BIGNUM *p = NULL;
+    BIGNUM *q = NULL;
+    BIGNUM *g = NULL;
+
     if (needPrivateExponent) {
-        (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize);
-        x = BN_bin2bn(buff, keyMaterial->xSize, NULL);
+        x = BinToBN(key->data + offset, keyMaterial->xSize);
+        offset += keyMaterial->xSize;
     }
 
-    offset += keyMaterial->xSize;
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->ySize) != 0) {
-        return NULL;
-    }
-    BIGNUM *y = BN_bin2bn(buff, keyMaterial->ySize, NULL);
-
+    y = BinToBN(key->data + offset, keyMaterial->ySize);
     offset += keyMaterial->ySize;
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->pSize) != 0) {
-        return NULL;
-    }
-    BIGNUM *p = BN_bin2bn(buff, keyMaterial->pSize, NULL);
 
+    p = BinToBN(key->data + offset, keyMaterial->pSize);
     offset += keyMaterial->pSize;
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->qSize) != 0) {
-        return NULL;
-    }
-    BIGNUM *q = BN_bin2bn(buff, keyMaterial->qSize, NULL);
 
+    q = BinToBN(key->data + offset, keyMaterial->qSize);
     offset += keyMaterial->qSize;
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->gSize) != 0) {
-        return NULL;
-    }
-    BIGNUM *g = BN_bin2bn(buff, keyMaterial->gSize, NULL);
 
-    DSA *dsa = DSA_new();
-    if (DSA_set0_key(dsa, y, x) != 1 || DSA_set0_pqg(dsa, p, q, g) != 1) {
-        return NULL;
+    g = BinToBN(key->data + offset, keyMaterial->gSize);
+
+    DSA *dsa = NULL;
+    do {
+        dsa = DSA_new();
+        if (dsa == NULL) {
+            break;
+        }
+
+        if (DSA_set0_key(dsa, y, x) != 1) {
+            DSA_free(dsa);
+            dsa = NULL;
+            break;
+        }
+
+        if (DSA_set0_pqg(dsa, p, q, g) != 1) {
+            DSA_free(dsa);
+            dsa = NULL;
+            break;
+        }
+    } while (0);
+
+    if (dsa == NULL) {
+        FreeBN(x);
+        FreeBN(y);
+        FreeBN(p);
+        FreeBN(q);
+        FreeBN(g);
     }
 
     return dsa;
@@ -126,14 +159,19 @@ int32_t OpensslSignDsa(
 
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
-        EVP_PKEY_free(pkey);
+        DSA_free(dsa);
+        return DSA_FAILED;
+    }
+
+    if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) {
+        EVP_PKEY_free(pkey);
+        DSA_free(dsa);
         return DSA_FAILED;
     }
 
-    EVP_PKEY_assign_DSA(pkey, dsa);
     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
     if (mctx == NULL) {
-        EVP_MD_CTX_free(mctx);
+        EVP_PKEY_free(pkey);
         return DSA_FAILED;
     }
 
@@ -145,22 +183,22 @@ int32_t OpensslSignDsa(
     }
 
     if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) {
-        EVP_MD_CTX_free(mctx);
         EVP_PKEY_free(pkey);
+        EVP_MD_CTX_free(mctx);
         return DSA_FAILED;
     }
 
     size_t signLen = signData->size;
     if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) {
-        EVP_MD_CTX_free(mctx);
         EVP_PKEY_free(pkey);
+        EVP_MD_CTX_free(mctx);
         return DSA_FAILED;
     }
 
     signData->size = signLen;
 
-    EVP_MD_CTX_free(mctx);
     EVP_PKEY_free(pkey);
+    EVP_MD_CTX_free(mctx);
 
     return DSA_SUCCESS;
 }
@@ -175,14 +213,19 @@ int32_t OpensslVerifyDsa(
 
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
-        EVP_PKEY_free(pkey);
+        DSA_free(dsa);
+        return DSA_FAILED;
+    }
+
+    if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) {
+        EVP_PKEY_free(pkey);
+        DSA_free(dsa);
         return DSA_FAILED;
     }
 
-    EVP_PKEY_assign_DSA(pkey, dsa);
     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
     if (mctx == NULL) {
-        EVP_MD_CTX_free(mctx);
+        EVP_PKEY_free(pkey);
         return DSA_FAILED;
     }
 
@@ -194,32 +237,35 @@ int32_t OpensslVerifyDsa(
     }
 
     if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) {
-        EVP_MD_CTX_free(mctx);
         EVP_PKEY_free(pkey);
+        EVP_MD_CTX_free(mctx);
         return DSA_FAILED;
     }
 
     if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) {
-        EVP_MD_CTX_free(mctx);
         EVP_PKEY_free(pkey);
+        EVP_MD_CTX_free(mctx);
         return DSA_FAILED;
     }
 
-    EVP_MD_CTX_free(mctx);
     EVP_PKEY_free(pkey);
+    EVP_MD_CTX_free(mctx);
 
     return DSA_SUCCESS;
 }
 
 int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey)
 {
-    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size);
+    uint8_t *data = x509Key->data;
+
+    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size);
     if (pkey == NULL) {
         return DSA_FAILED;
     }
 
-    DSA *dsa = EVP_PKEY_get1_DSA(pkey);
+    DSA *dsa = EVP_PKEY_get0_DSA(pkey);
     if (dsa == NULL) {
+        EVP_PKEY_free(pkey);
         return DSA_FAILED;
     }
     int32_t ySize = BN_num_bytes(DSA_get0_pub_key(dsa));
@@ -227,6 +273,7 @@ int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey)
     int32_t qSize = BN_num_bytes(DSA_get0_q(dsa));
     int32_t gSize = BN_num_bytes(DSA_get0_g(dsa));
     if ((ySize <= 0) || (pSize <= 0) || (qSize <= 0) || (gSize <= 0)) {
+        EVP_PKEY_free(pkey);
         return DSA_FAILED;
     }
     struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)publicKey->data;
@@ -238,18 +285,26 @@ int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey)
     keyMaterial->qSize = qSize;
     keyMaterial->gSize = gSize;
 
-    if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize) == 0) ||
-        (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize) ==
-            0) ||
-        (BN_bn2bin(DSA_get0_q(dsa),
-            publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize) == 0) ||
-        (BN_bn2bin(DSA_get0_g(dsa),
-            publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize + qSize) == 0)) {
-        free(publicKey->data);
-        return DSA_FAILED;
-    }
+    int32_t result = DSA_FAILED;
+    uint32_t offset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize;
+    do {
+        if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + offset) == 0)) {
+            break;
+        }
+        if (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + offset + ySize) == 0) {
+            break;
+        }
+        if (BN_bn2bin(DSA_get0_q(dsa), publicKey->data + offset + ySize + pSize) == 0) {
+            break;
+        }
+        if (BN_bn2bin(DSA_get0_g(dsa), publicKey->data + offset + ySize + pSize + qSize) == 0) {
+            break;
+        }
+        result = DSA_SUCCESS;
+    } while (0);
 
-    return DSA_SUCCESS;
+    EVP_PKEY_free(pkey);
+    return result;
 }
 
 void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key)
@@ -257,12 +312,14 @@ void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key)
     uint8_t *tmp = NULL;
     int32_t length = i2d_PUBKEY(pkey, &tmp);
     x509Key->size = length;
-    x509Key->data = tmp;
+    if (tmp != NULL) {
+        (void)memcpy_s(x509Key->data, x509Key->size, tmp, length);
+        free(tmp);
+    }
 }
 
 int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key)
 {
-    int32_t ret;
     uint32_t opensslKeyByteLen = HKS_KEY_BYTES(keySize);
     if (opensslKeyByteLen < OPENSSL_DSA_MIN_KEY_LEN) {
         opensslKeyByteLen = OPENSSL_DSA_MIN_KEY_LEN;
@@ -285,7 +342,7 @@ int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBl
     const BIGNUM *g = DSA_get0_g(EVP_PKEY_get0_DSA(pkey));
 
     int32_t offset = sizeof(struct KeyMaterialDsa);
-    ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x)));
+    int32_t ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x)));
     if (ret <= 0) {
         return DSA_FAILED;
     }

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_ecc_mt_test.h"
+#include "openssl_ecc_helper.h"
 
 #include <openssl/ec.h>
 #include <openssl/evp.h>
@@ -105,29 +105,38 @@ static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keyLen, u
         return ECC_FAILED;
     }
 
-    const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey);
-    if (ecGroup == NULL) {
-        return ECC_FAILED;
-    }
+    int32_t result = ECC_FAILED;
+    do {
+        const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey);
+        if (ecGroup == NULL) {
+            break;
+        }
 
-    if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) <= 0) {
-        return ECC_FAILED;
-    }
+        if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) != 1) {
+            break;
+        }
 
-    const BIGNUM *priv = EC_KEY_get0_private_key(eccKey);
-    if (priv == NULL) {
-        return ECC_FAILED;
-    }
+        const BIGNUM *priv = EC_KEY_get0_private_key(eccKey);
+        if (priv == NULL) {
+            break;
+        }
 
-    if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) {
-        return ECC_FAILED;
-    }
+        if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) {
+            break;
+        }
 
-    *output = rawMaterial;
-    *outputSize = rawMaterialLen;
+        *outputSize = rawMaterialLen;
+
+        if (memcpy_s(*output, *outputSize, rawMaterial, rawMaterialLen) != 0) {
+            break;
+        }
+
+        result = ECC_SUCCESS;
+    } while (0);
 
     BN_free(pubX);
     BN_free(pubY);
+    free(rawMaterial);
     return ECC_SUCCESS;
 }
 
@@ -144,10 +153,12 @@ int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key)
     }
 
     if (EC_KEY_generate_key(eccKey) <= 0) {
+        EC_KEY_free(eccKey);
         return ECC_FAILED;
     }
 
     if (EccSaveKeyMaterial(eccKey, keyLen, &key->data, &key->size) != ECC_SUCCESS) {
+        EC_KEY_free(eccKey);
         return ECC_FAILED;
     }
 
@@ -242,7 +253,11 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool sign)
 
     if (sign) {
         BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, privateSize, NULL);
-        if (pri == NULL || EC_KEY_set_private_key(eccKey, pri) <= 0) {
+        if (pri == NULL) {
+            EC_KEY_free(eccKey);
+            return NULL;
+        }
+        if (EC_KEY_set_private_key(eccKey, pri) != 1) {
             BN_free(pri);
             EC_KEY_free(eccKey);
             return NULL;
@@ -268,7 +283,7 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest,
         return NULL;
     }
 
-    if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) {
+    if (EVP_PKEY_assign_EC_KEY(key, eccKey) != 1) {
         EC_KEY_free(eccKey);
         EVP_PKEY_free(key);
         return NULL;
@@ -283,14 +298,14 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest,
     if (sign) {
         int32_t ret = EVP_DigestSignInit(ctx, NULL, md, NULL, key);
         EVP_PKEY_free(key);
-        if (ret <= 0) {
+        if (ret != 1) {
             EVP_MD_CTX_free(ctx);
             return NULL;
         }
     } else {
         int ret = EVP_DigestVerifyInit(ctx, NULL, md, NULL, key);
         EVP_PKEY_free(key);
-        if (ret <= 0) {
+        if (ret != 1) {
             EVP_MD_CTX_free(ctx);
             return NULL;
         }
@@ -305,18 +320,18 @@ int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *m
         return ECC_FAILED;
     }
 
-    if (EVP_DigestSignUpdate(ctx, message->data, message->size) <= 0) {
+    if (EVP_DigestSignUpdate(ctx, message->data, message->size) != 1) {
         EVP_MD_CTX_free(ctx);
         return ECC_FAILED;
     }
     size_t req = 0;
 
-    if (EVP_DigestSignFinal(ctx, NULL, &req) <= 0) {
+    if (EVP_DigestSignFinal(ctx, NULL, &req) != 1) {
         EVP_MD_CTX_free(ctx);
         return ECC_FAILED;
     }
 
-    if (EVP_DigestSignFinal(ctx, signature->data, &req) <= 0) {
+    if (EVP_DigestSignFinal(ctx, signature->data, &req) != 1) {
         EVP_MD_CTX_free(ctx);
         return ECC_FAILED;
     }
@@ -334,12 +349,12 @@ int32_t EcdsaVerify(
         return ECC_FAILED;
     }
 
-    if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) <= 0) {
+    if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != 1) {
         EVP_MD_CTX_free(ctx);
         return ECC_FAILED;
     }
 
-    if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) <= 0) {
+    if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != 1) {
         EVP_MD_CTX_free(ctx);
         return ECC_FAILED;
     }
@@ -412,8 +427,12 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey)
         }
 
         ret = ECC_SUCCESS;
-        eccPublicKey->data = keyBuffer;
         eccPublicKey->size = totalSize;
+        if (memcpy_s(eccPublicKey->data, eccPublicKey->size, keyBuffer, totalSize) != 0) {
+            HKS_FREE_PTR(keyBuffer);
+            break;
+        }
+        HKS_FREE_PTR(keyBuffer);
     } while (0);
 
     SELF_FREE_PTR(x, BN_free);
@@ -436,14 +455,16 @@ int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey)
 
     EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey);
     if (ecKey == NULL) {
+        EVP_PKEY_free(pkey);
         return ECC_FAILED;
     }
 
     if (EcKeyToPublicKey(ecKey, publicKey) != ECC_SUCCESS) {
+        EVP_PKEY_free(pkey);
         return ECC_FAILED;
     };
 
-    SELF_FREE_PTR(pkey, EVP_PKEY_free);
+    EVP_PKEY_free(pkey);
     return ECC_SUCCESS;
 }
 
@@ -489,7 +510,19 @@ int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key)
     uint8_t *tmp = NULL;
     int32_t length = i2d_PUBKEY(pkey, &tmp);
     x509Key->size = length;
-    x509Key->data = tmp;
+    if (tmp == NULL) {
+        EVP_PKEY_free(pkey);
+        return ECC_FAILED;
+    }
+
+    if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) {
+        EVP_PKEY_free(pkey);
+        free(tmp);
+        return ECC_FAILED;
+    }
+
+    EVP_PKEY_free(pkey);
+    free(tmp);
     return ECC_SUCCESS;
 }
 
@@ -582,7 +615,9 @@ int32_t EcdhAgreeKey(
         ret = ECC_SUCCESS;
     } while (0);
 
-    EVP_PKEY_CTX_free(ctx);
+    if (ctx != NULL) {
+        EVP_PKEY_CTX_free(ctx);
+    }
     if (peerKey != NULL) {
         EVP_PKEY_free(peerKey);
     }

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_hmac_mt_test.h"
+#include "openssl_hmac_helper.h"
 
 int32_t HmacGenerateKey(int key_len, struct HksBlob *key)
 {
@@ -24,7 +24,8 @@ int32_t HmacGenerateKey(int key_len, struct HksBlob *key)
         return HMAC_FAILED;
     }
 
-    if (RAND_bytes(tmpKey, keySizeByte) <= 0) {
+    if (RAND_bytes(tmpKey, keySizeByte) != 1) {
+        free(tmpKey);
         return HMAC_FAILED;
     }
 

interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "hks_openssl_rsa_test_mt.h"
+#include "openssl_rsa_helper.h"
 
 #include <openssl/evp.h>
 #include <openssl/x509.h>
@@ -31,51 +31,57 @@ void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob
     keyMaterial->eSize = keyByteLen;
     keyMaterial->dSize = keyByteLen;
 
-    int dataLen;
     uint8_t tmpBuff[keyByteLen];
     memset_s(tmpBuff, keyByteLen, 0x00, keyByteLen);
 
     uint32_t offset = sizeof(*keyMaterial);
-    dataLen = BN_bn2bin(RSA_get0_n(EVP_PKEY_get0_RSA(pkey)), tmpBuff);
-    if (dataLen > 0) {
-        (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->nSize, tmpBuff, dataLen);
+    if (BN_bn2binpad(RSA_get0_n(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) {
+        (void)memcpy_s(key->data + offset, keyMaterial->nSize, tmpBuff, keyMaterial->nSize);
     }
 
     offset += keyMaterial->nSize;
-    dataLen = BN_bn2bin(RSA_get0_e(EVP_PKEY_get0_RSA(pkey)), tmpBuff);
-    if (dataLen > 0) {
-        (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->eSize, tmpBuff, dataLen);
+    if (BN_bn2binpad(RSA_get0_e(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) {
+        (void)memcpy_s(key->data + offset, keyMaterial->eSize, tmpBuff, keyMaterial->eSize);
     }
 
     offset += keyMaterial->eSize;
-    dataLen = BN_bn2bin(RSA_get0_d(EVP_PKEY_get0_RSA(pkey)), tmpBuff);
-    if (dataLen > 0) {
-        (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->dSize, tmpBuff, dataLen);
+    if (BN_bn2binpad(RSA_get0_d(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) {
+        (void)memcpy_s(key->data + offset, keyMaterial->dSize, tmpBuff, keyMaterial->dSize);
     }
+    key->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize;
 }
 
 EVP_PKEY *GenerateRSAKey(const uint32_t keySize)
 {
+    BIGNUM *bne = BN_new();
+    if (bne == NULL) {
+        return NULL;
+    }
+    BN_set_word(bne, RSA_F4);
+
+    RSA *rsa = RSA_new();
+    if (rsa == NULL) {
+        BN_free(bne);
+        return NULL;
+    }
+    
+    if (RSA_generate_key_ex(rsa, keySize, bne, NULL) != 1) {
+        RSA_free(rsa);
+        BN_free(bne);
+        return NULL;
+    }
+    BN_free(bne);
+
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
         return NULL;
     }
-    RSA *rsa = RSA_new();
-    if (rsa == NULL) {
-        EVP_PKEY_free(pkey);
-        return NULL;
-    }
-    BIGNUM *bne = BN_new();
-    BN_set_word(bne, RSA_F4);
-    if (bne == NULL) {
-        RSA_free(rsa);
-        EVP_PKEY_free(pkey);
-        return NULL;
-    }
-    RSA_generate_key_ex(rsa, keySize, bne, NULL);
-    BN_free(bne);
 
-    EVP_PKEY_assign_RSA(pkey, rsa);
+    if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
+        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
+        return NULL;
+    }
 
     return pkey;
 }
@@ -85,23 +91,30 @@ void OpensslGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key)
     uint8_t *tmp = NULL;
     int32_t length = i2d_PUBKEY(pkey, &tmp);
     x509Key->size = length;
-    x509Key->data = tmp;
+    if (tmp != NULL) {
+        (void)memcpy_s(x509Key->data, x509Key->size, tmp, length);
+        free(tmp);
+    }
 }
 
 int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey)
 {
-    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size);
+    uint8_t *data = x509Key->data;
+
+    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size);
     if (pkey == NULL) {
         return RSA_FAILED;
     }
-    RSA *rsa = EVP_PKEY_get1_RSA(pkey);
+    RSA *rsa = EVP_PKEY_get0_RSA(pkey);
     if (rsa == NULL) {
+        EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
 
     int32_t nSize = BN_num_bytes(RSA_get0_n(rsa));
     int32_t eSize = BN_num_bytes(RSA_get0_e(rsa));
     if ((nSize <= 0) || (eSize <= 0)) {
+        EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
 
@@ -112,10 +125,10 @@ int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey)
     pubKeyInfo->eOrYSize = eSize;
     if ((BN_bn2bin(RSA_get0_n(rsa), publicKey->data + sizeof(struct HksPubKeyInfo)) == 0) ||
         (BN_bn2bin(RSA_get0_e(rsa), publicKey->data + sizeof(struct HksPubKeyInfo) + nSize) == 0)) {
-        free(publicKey->data);
+        EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
-
+    EVP_PKEY_free(pkey);
     return RSA_SUCCESS;
 }
 
@@ -124,30 +137,45 @@ static RSA *InitRsa(struct HksBlob *key, const bool needPrivateExponent)
     const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data);
     uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)];
 
-    uint32_t offset = sizeof(*keyMaterial);
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize) != 0) {
-        return NULL;
-    }
-
-    BIGNUM *n = BN_bin2bn(buff, keyMaterial->nSize, NULL);
-    offset += keyMaterial->nSize;
-    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize) != 0) {
-        return NULL;
-    }
-
-    BIGNUM *e = BN_bin2bn(buff, keyMaterial->eSize, NULL);
-    offset += keyMaterial->eSize;
+    BIGNUM *n = NULL;
+    BIGNUM *e = NULL;
     BIGNUM *d = NULL;
-    if (needPrivateExponent) {
-        (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize);
 
-        d = BN_bin2bn(buff, keyMaterial->dSize, NULL);
+    uint32_t offset = sizeof(*keyMaterial);
+    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize) == 0) {
+        n = BN_bin2bn(buff, keyMaterial->nSize, NULL);
+    }
+    offset += keyMaterial->nSize;
+
+    if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize) == 0) {
+        e = BN_bin2bn(buff, keyMaterial->eSize, NULL);
+    }
+    offset += keyMaterial->eSize;
+
+    if (needPrivateExponent) {
+        if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize) == 0) {
+            d = BN_bin2bn(buff, keyMaterial->dSize, NULL);
+        }
     }
 
     RSA *rsa = RSA_new();
-    int32_t ret = RSA_set0_key(rsa, n, e, d);
-    if (ret != 1) {
-        return NULL;
+    if (rsa != NULL) {
+        if (RSA_set0_key(rsa, n, e, d) != 1) {
+            RSA_free(rsa);
+            rsa = NULL;
+        }
+    }
+
+    if (rsa == NULL) {
+        if (n != NULL) {
+            BN_free(n);
+        }
+        if (e != NULL) {
+            BN_free(e);
+        }
+        if (d != NULL) {
+            BN_free(d);
+        }
     }
 
     return rsa;
@@ -172,6 +200,7 @@ static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType)
             return NULL;
     }
 }
+
 int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding,
     enum HksKeyDigest digestType)
 {
@@ -181,40 +210,41 @@ int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct
     }
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
-        EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
-    EVP_PKEY_assign_RSA(pkey, rsa);
+    if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
+        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
+        return RSA_FAILED;
+    }
     EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL);
     if (ectx == NULL) {
         EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
-    EVP_PKEY_encrypt_init(ectx);
-
-    EVP_PKEY_CTX_set_rsa_padding(ectx, padding);
-
+    if ((EVP_PKEY_encrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) {
+        EVP_PKEY_CTX_free(ectx);
+        EVP_PKEY_free(pkey);
+        return RSA_FAILED;
+    }
     if (padding == RSA_PKCS1_OAEP_PADDING) {
         const EVP_MD *md = GetOpensslDigestType(digestType);
-        if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) <= 0) ||
-            (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) <= 0)) {
+        if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) ||
+            (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) {
             EVP_PKEY_CTX_free(ectx);
             EVP_PKEY_free(pkey);
             return RSA_FAILED;
         }
     }
     size_t outLen = outData->size;
-    int result = EVP_PKEY_encrypt(ectx, outData->data, &outLen, inData->data, inData->size);
-    if (result != 1) {
+    if (EVP_PKEY_encrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_PKEY_CTX_free(ectx);
         EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
     outData->size = outLen;
-
     EVP_PKEY_CTX_free(ectx);
     EVP_PKEY_free(pkey);
-
     return RSA_SUCCESS;
 }
 
@@ -227,31 +257,35 @@ int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct
     }
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
-        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
+        return RSA_FAILED;
+    }
+    if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
+        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
         return RSA_FAILED;
     }
-    EVP_PKEY_assign_RSA(pkey, rsa);
     EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL);
     if (ectx == NULL) {
         EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
-    EVP_PKEY_decrypt_init(ectx);
-
-    EVP_PKEY_CTX_set_rsa_padding(ectx, padding);
-
+    if ((EVP_PKEY_decrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) {
+        EVP_PKEY_CTX_free(ectx);
+        EVP_PKEY_free(pkey);
+        return RSA_FAILED;
+    }
     if (padding == RSA_PKCS1_OAEP_PADDING) {
         const EVP_MD *md = GetOpensslDigestType(digestType);
-        if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) <= 0) ||
-            (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) <= 0)) {
+        if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) ||
+            (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) {
             EVP_PKEY_CTX_free(ectx);
             EVP_PKEY_free(pkey);
             return RSA_FAILED;
         }
     }
     size_t outLen = outData->size;
-    int result = EVP_PKEY_decrypt(ectx, outData->data, &outLen, inData->data, inData->size);
-    if (result != 1) {
+    if (EVP_PKEY_decrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) {
         EVP_PKEY_CTX_free(ectx);
         EVP_PKEY_free(pkey);
         return RSA_FAILED;
@@ -274,14 +308,19 @@ int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData
 
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
-        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
+        return RSA_FAILED;
+    }
+
+    if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
+        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
         return RSA_FAILED;
     }
 
-    EVP_PKEY_assign_RSA(pkey, rsa);
     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
     if (mctx == NULL) {
-        EVP_MD_CTX_free(mctx);
+        EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
 
@@ -293,9 +332,9 @@ int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData
     }
 
     if (padding == RSA_PKCS1_PSS_PADDING) {
-        if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 &&
-            EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) {
+        if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) {
             EVP_MD_CTX_free(mctx);
+            EVP_PKEY_free(pkey);
             return RSA_FAILED;
         }
     }
@@ -330,16 +369,19 @@ int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signDa
     }
     EVP_PKEY *pkey = EVP_PKEY_new();
     if (pkey == NULL) {
+        RSA_free(rsa);
+        return RSA_FAILED;
+    }
+    if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) {
+        EVP_PKEY_free(pkey);
+        RSA_free(rsa);
+        return RSA_FAILED;
+    }
+    EVP_MD_CTX *mctx = EVP_MD_CTX_new();
+    if (mctx == NULL) {
         EVP_PKEY_free(pkey);
         return RSA_FAILED;
     }
-    EVP_PKEY_assign_RSA(pkey, rsa);
-    EVP_MD_CTX *mctx = EVP_MD_CTX_new();
-    if (mctx == NULL) {
-        EVP_MD_CTX_free(mctx);
-        return RSA_FAILED;
-    }
-
     const EVP_MD *md = GetOpensslDigestType(digestType);
     if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) {
         EVP_MD_CTX_free(mctx);
@@ -348,9 +390,9 @@ int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signDa
     }
 
     if (padding == RSA_PKCS1_PSS_PADDING) {
-        if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 &&
-            EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) {
+        if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) {
             EVP_MD_CTX_free(mctx);
+            EVP_PKEY_free(pkey);
             return RSA_FAILED;
         }
     }

ohos.build

@@ -26,7 +26,8 @@
       "test_list": [
         "//base/security/huks:huks_sdk_test",
         "//base/security/huks/services/huks_standard/huks_service/main/test/unittest:huks_multithread_test",
-        "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test"
+        "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test",
+        "//base/security/huks/test/stability:huks_stability_test"
       ]
     }
   }

services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c

@@ -87,6 +87,8 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo
             HKS_LOG_E("RSA_set0_key error %s", ERR_reason_error_string(ERR_get_error()));
             break;
         }
+        rsaN = NULL;
+        rsaE = NULL;
         pkey = EVP_PKEY_new();
         if (pkey == NULL) {
             HKS_LOG_E("pkey is null");
@@ -179,8 +181,6 @@ static int32_t EccToX509PublicKey(
             break;
         }
 
-        /* ecKey need to be set to null to prevent Double-Free */
-        ecKey = NULL;
         ret = EvpKeyToX509Format(pkey, x509Key);
     } while (0);
 
@@ -614,7 +614,8 @@ static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey)
     const BIGNUM *pubKey = DH_get0_pub_key(dh);
     uint32_t pubKeySize = BN_num_bytes(pubKey);
 
-    uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + pubKeySize);
+    uint32_t totalSize = sizeof(struct KeyMaterialDh) + pubKeySize;
+    uint8_t *keyBuffer = HksMalloc(totalSize);
     if (keyBuffer == NULL) {
         HKS_LOG_E("alloc keyBuffer failed");
         return HKS_ERROR_MALLOC_FAIL;
@@ -628,7 +629,7 @@ static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey)
 
     BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh));
 
-    dhPublicKey->size = pubKeySize;
+    dhPublicKey->size = totalSize;
     dhPublicKey->data = keyBuffer;
 
     return HKS_SUCCESS;
@@ -642,7 +643,9 @@ int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob
         return HKS_ERROR_INVALID_ARGUMENT;
     }
 
-    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size);
+    uint8_t *data = x509Key->data;
+
+    EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size);
     if (pkey == NULL) {
         return HKS_ERROR_INVALID_ARGUMENT;
     }

services/huks_standard/huks_service/main/core/src/hks_storage.c

@@ -283,6 +283,71 @@ static int32_t MakeDirIfNotExist(const char *path)
     return HKS_SUCCESS;
 }
 
+static int32_t HksStorageWriteFile(
+    const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)
+{
+#ifdef HKS_SUPPORT_THREAD
+    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
+    int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
+    if (ret != HKS_SUCCESS) {
+        HKS_LOG_E("get full path failed, ret = %d.", ret);
+        return ret;
+    }
+
+    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
+    HksStorageFileLockWrite(lock);
+    ret = HksFileWrite(path, fileName, offset, buf, len);
+    HksStorageFileUnlockWrite(lock);
+    HksStorageFileLockRelease(lock);
+    return ret;
+#else
+    return HksFileWrite(path, fileName, offset, buf, len);
+#endif
+}
+
+static uint32_t HksStorageReadFile(
+    const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
+{
+#ifdef HKS_SUPPORT_THREAD
+    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
+    int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
+    if (ret != HKS_SUCCESS) {
+        HKS_LOG_E("get full path failed, ret = %d.", ret);
+        return 0;
+    }
+
+    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
+    HksStorageFileLockRead(lock);
+    uint32_t size = HksFileRead(path, fileName, offset, buf, len);
+    HksStorageFileUnlockRead(lock);
+    HksStorageFileLockRelease(lock);
+#else
+    uint32_t size = HksFileRead(path, fileName, offset, buf, len);
+#endif
+    return size;
+}
+
+static int32_t HksStorageRemoveFile(const char *path, const char *fileName)
+{
+#ifdef HKS_SUPPORT_THREAD
+    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
+    int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
+    if (ret != HKS_SUCCESS) {
+        HKS_LOG_E("get full path failed, ret = %d.", ret);
+        return ret;
+    }
+
+    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
+    HksStorageFileLockWrite(lock);
+    ret = HksFileRemove(path, fileName);
+    HksStorageFileUnlockWrite(lock);
+    HksStorageFileLockRelease(lock);
+#else
+    int32_t ret = HksFileRemove(path, fileName);
+#endif
+    return ret;
+}
+
 #ifdef SUPPORT_STORAGE_BACKUP
 static int32_t GetBakFullPath(const char *path, const char *processName, const char *storeName,
     struct HksStoreFileInfo *fileInfo)
@@ -329,7 +394,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName,
 
     int32_t ret;
     do {
-        size = HksFileRead(srcPath, srcFileName, 0, buffer, size);
+        size = HksStorageReadFile(srcPath, srcFileName, 0, buffer, size);
         if (size == 0) {
             HKS_LOG_E("read file failed, ret = %u.", size);
             ret = HKS_ERROR_READ_FILE_FAIL;
@@ -342,7 +407,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName,
             break;
         }
 
-        ret = HksFileWrite(destPath, destFileName, 0, buffer, size);
+        ret = HksStorageWriteFile(destPath, destFileName, 0, buffer, size);
         if (ret != HKS_SUCCESS) {
             HKS_LOG_E("file write destPath failed, ret = %d.", ret);
             break;
@@ -394,22 +459,7 @@ static int32_t GetKeyBlobFromFile(const char *path, const char *fileName, struct
         return HKS_ERROR_INSUFFICIENT_DATA;
     }
 
-#ifdef HKS_SUPPORT_THREAD
-    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
-    int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
-    if (ret != HKS_SUCCESS) {
-        HKS_LOG_E("get full path failed, ret = %d.", ret);
-        return ret;
-    }
-
-    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
-    HksStorageFileLockRead(lock);
-    size = HksFileRead(path, fileName, 0, keyBlob->data, keyBlob->size);
-    HksStorageFileUnlockRead(lock);
-    HksStorageFileLockRelease(lock);
-#else
-    size = HksFileRead(path, fileName, 0, keyBlob->data, keyBlob->size);
-#endif
+    size = HksStorageReadFile(path, fileName, 0, keyBlob->data, keyBlob->size);
     if (size == 0) {
         HKS_LOG_E("file read failed, ret = %u.", size);
         return HKS_ERROR_READ_FILE_FAIL;
@@ -434,23 +484,7 @@ static int32_t SaveKeyBlob(const char *processPath, const char *path, const char
         return ret;
     }
 
-#ifdef HKS_SUPPORT_THREAD
-    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
-    ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
-    if (ret != HKS_SUCCESS) {
-        HKS_LOG_E("get full path failed, ret = %d.", ret);
-        return ret;
-    }
-
-    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
-    HksStorageFileLockWrite(lock);
-    ret = HksFileWrite(path, fileName, 0, keyBlob->data, keyBlob->size);
-    HksStorageFileUnlockWrite(lock);
-    HksStorageFileLockRelease(lock);
-    return ret;
-#else
-    return HksFileWrite(path, fileName, 0, keyBlob->data, keyBlob->size);
-#endif
+    return HksStorageWriteFile(path, fileName, 0, keyBlob->data, keyBlob->size);
 }
 
 static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo)
@@ -461,22 +495,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo)
         return HKS_ERROR_NOT_EXIST;
     }
 
-#ifdef HKS_SUPPORT_THREAD
-    char fullPath[HKS_MAX_FILE_NAME_LEN] = {0};
-    int32_t ret = HksGetFileName(fileInfo->mainPath.path, fileInfo->mainPath.fileName, fullPath, HKS_MAX_FILE_NAME_LEN);
-    if (ret != HKS_SUCCESS) {
-        HKS_LOG_E("get full path failed, ret = %d.", ret);
-        return ret;
-    }
-
-    HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath);
-    HksStorageFileLockWrite(lock);
-    ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName);
-    HksStorageFileUnlockWrite(lock);
-    HksStorageFileLockRelease(lock);
-#else
-    int32_t ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName);
-#endif
+    int32_t ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName);
     if (ret != HKS_SUCCESS) {
         HKS_LOG_E("delete key remove file failed, ret = %d.", ret);
         return ret;
@@ -489,7 +508,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo)
 
     int32_t ret = HKS_SUCCESS;
     if (isMainFileExist == HKS_SUCCESS) {
-        ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName);
+        ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName);
         if (ret != HKS_SUCCESS) {
             HKS_LOG_E("delete key remove file failed, ret = %d.", ret);
             return ret;
@@ -497,7 +516,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo)
     }
 
     if (isBakFileExist == HKS_SUCCESS) {
-        ret = HksFileRemove(fileInfo->bakPath.path, fileInfo->bakPath.fileName);
+        ret = HksStorageRemoveFile(fileInfo->bakPath.path, fileInfo->bakPath.fileName);
         if (ret != HKS_SUCCESS) {
             HKS_LOG_E("delete key remove bakfile failed, ret = %d.", ret);
             return ret;

services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp

@@ -251,6 +251,6 @@ void HksService::OnStop()
     runningState_ = STATE_NOT_START;
     registerToService_ = false;
 }
-} // UniversalKeystore
+} // Hks
 } // Security
 } // OHOS

services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c

@@ -45,7 +45,7 @@ static BOOL MessageHandle(Service *service, Request *request)
 static TaskConfig GetTaskConfig(Service *service)
 {
     (void)service;
-    TaskConfig config = {LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK};
+    TaskConfig config = { LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK };
     return config;
 }
 
@@ -54,7 +54,7 @@ static HksMgrService g_hksMgrService = {
     .Initialize = Initialize,
     .MessageHandle = MessageHandle,
     .GetTaskConfig = GetTaskConfig,
-    .identity = {-1, -1, NULL}
+    .identity = { -1, -1, NULL }
 };
 
 static void Init(void)

services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c

@@ -30,7 +30,7 @@ static HksMgrFeature g_hksMgrFeature = {
     SERVER_IPROXY_IMPL_BEGIN,
     .Invoke = Invoke,
     IPROXY_END,
-    .identity = {-1, -1, NULL},
+    .identity = { -1, -1, NULL },
 };
 static const char *FEATURE_GetName(Feature *feature)
 {

test/stability/BUILD.gn

@@ -0,0 +1,52 @@
+# Copyright (C) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//base/security/huks/huks.gni")
+import("//build/ohos.gni")
+import("//build/test.gni")
+
+module_output_path = "huks_standard/huks_standard_test"
+
+ohos_moduletest("huks_stability_test") {
+  module_out_path = module_output_path
+  testonly = true
+  sources = [
+    "src/api_pressure_test.cpp",
+    "src/pressure_test.cpp",
+  ]
+
+  defines = [
+    "L2_STANDARD",
+    "_HARDWARE_ROOT_KEY_",
+    "_HUKS_LOG_ENABLE_",
+  ]
+
+  if (use_crypto_lib == "openssl") {
+    defines += [ "_USE_OPENSSL_" ]
+  }
+  if (use_crypto_lib == "mbedtls") {
+    defines += [ "_USE_MBEDTLS_" ]
+  }
+
+  include_dirs = [
+    "//utils/native/base/include",
+    "//base/security/huks/interfaces/innerkits/huks_standard/main/include",
+    "//base/security/huks/frameworks/huks_standard/main/common/include",
+  ]
+
+  deps = [
+    "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk",
+    "//third_party/googletest:gtest_main",
+    "//utils/native/base:utils",
+  ]
+}