1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <iostream>
18 
19 #include "file_ex.h"
20 #include "hks_ability.h"
21 #include "hks_config.h"
22 #include "hks_crypto_hal.h"
23 #include "hks_crypto_hal_common.h"
24 #include "hks_mem.h"
25 
26 using namespace testing::ext;
27 namespace OHOS {
28 namespace Security {
29 namespace Huks {
30 namespace UnitTest {
31 namespace {
32 struct TestCaseParams {
33     HksUsageSpec usageSpec = {0};
34     std::string keyData;
35     std::string hexData;
36     HksStageType runStage = HksStageType::HKS_STAGE_THREE;
37 
38     HksErrorCode encryptResult = HksErrorCode::HKS_SUCCESS;
39 };
40 
41 const uint32_t IV_SIZE = 16;
42 const uint32_t AEAD_SIZE = 16;
43 uint8_t IV[IV_SIZE] = {0};
44 HksCipherParam TAG_IV = { .iv = { .size = IV_SIZE, .data = IV } };
45 HksAeadParam AEAD_PARAM = {
46     .nonce = { .size = IV_SIZE, .data = IV },
47     .aad = { .size = 0, .data = nullptr },
48     .tagLenEnc = IV_SIZE,
49     .payloadLen = 0,
50 };
51 
52 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS = {
53     .usageSpec = {
54         .algType = HKS_ALG_AES,
55         .mode = HKS_MODE_CBC,
56         .padding = HKS_PADDING_NONE,
57         .digest = HKS_DIGEST_NONE,
58         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
59         .algParam = &TAG_IV,
60     },
61     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
62     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
63 
64     .encryptResult = HKS_SUCCESS,
65 };
66 
67 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS = {
68     .usageSpec = {
69         .algType = HKS_ALG_AES,
70         .mode = HKS_MODE_CBC,
71         .padding = HKS_PADDING_PKCS7,
72         .digest = HKS_DIGEST_NONE,
73         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
74         .algParam = &TAG_IV,
75     },
76     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
77     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
78 
79     .encryptResult = HKS_SUCCESS,
80 };
81 
82 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS = {
83     .usageSpec = {
84         .algType = HKS_ALG_AES,
85         .mode = HKS_MODE_CTR,
86         .padding = HKS_PADDING_NONE,
87         .digest = HKS_DIGEST_NONE,
88         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
89         .algParam = &TAG_IV,
90     },
91     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
92     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
93 
94     .encryptResult = HKS_SUCCESS,
95 };
96 
97 #ifdef HKS_UNTRUSTED_RUNNING_ENV
98 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS = {
99     .usageSpec = {
100         .algType = HKS_ALG_AES,
101         .mode = HKS_MODE_ECB,
102         .padding = HKS_PADDING_NONE,
103         .digest = HKS_DIGEST_NONE,
104         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
105         .algParam = nullptr,
106     },
107     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
108     .hexData = "00112233445566778899aabbccddeeff",
109 
110     .encryptResult = HKS_SUCCESS,
111 };
112 
113 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS = {
114     .usageSpec = {
115         .algType = HKS_ALG_AES,
116         .mode = HKS_MODE_ECB,
117         .padding = HKS_PADDING_PKCS7,
118         .digest = HKS_DIGEST_NONE,
119         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
120         .algParam = nullptr,
121     },
122     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
123     .hexData = "00112233445566778899aabbccddeeff",
124 #if defined(_USE_OPENSSL_)
125     .encryptResult = HKS_SUCCESS,
126 #endif
127 #if defined(_USE_MBEDTLS_)
128     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
129 #endif
130 };
131 #endif
132 
133 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS = {
134     .usageSpec = {
135         .algType = HKS_ALG_AES,
136         .mode = HKS_MODE_GCM,
137         .padding = HKS_PADDING_NONE,
138         .digest = HKS_DIGEST_NONE,
139         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
140         .algParam = &AEAD_PARAM,
141     },
142     .keyData = "933c213c1f8c844ffcc03f5f7e146a88",
143     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
144 
145     .encryptResult = HKS_SUCCESS,
146 };
147 
148 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS = {
149     .usageSpec = {
150         .algType = HKS_ALG_AES,
151         .mode = HKS_MODE_CBC,
152         .padding = HKS_PADDING_NONE,
153         .digest = HKS_DIGEST_NONE,
154         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
155         .algParam = &TAG_IV,
156     },
157     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
158     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
159 
160     .encryptResult = HKS_SUCCESS,
161 };
162 
163 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS = {
164     .usageSpec = {
165         .algType = HKS_ALG_AES,
166         .mode = HKS_MODE_CBC,
167         .padding = HKS_PADDING_PKCS7,
168         .digest = HKS_DIGEST_NONE,
169         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
170         .algParam = &TAG_IV,
171     },
172     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
173     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
174 
175     .encryptResult = HKS_SUCCESS,
176 };
177 
178 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS = {
179     .usageSpec = {
180         .algType = HKS_ALG_AES,
181         .mode = HKS_MODE_CTR,
182         .padding = HKS_PADDING_NONE,
183         .digest = HKS_DIGEST_NONE,
184         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
185         .algParam = &TAG_IV,
186     },
187     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
188     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
189 
190     .encryptResult = HKS_SUCCESS,
191 };
192 
193 #ifdef HKS_UNTRUSTED_RUNNING_ENV
194 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS = {
195     .usageSpec = {
196         .algType = HKS_ALG_AES,
197         .mode = HKS_MODE_ECB,
198         .padding = HKS_PADDING_NONE,
199         .digest = HKS_DIGEST_NONE,
200         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
201         .algParam = nullptr,
202     },
203     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
204     .hexData = "00112233445566778899aabbccddeeff",
205 
206     .encryptResult = HKS_SUCCESS,
207 };
208 
209 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS = {
210     .usageSpec = {
211         .algType = HKS_ALG_AES,
212         .mode = HKS_MODE_ECB,
213         .padding = HKS_PADDING_PKCS7,
214         .digest = HKS_DIGEST_NONE,
215         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
216         .algParam = nullptr,
217     },
218     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
219     .hexData = "00112233445566778899aabbccddeeff",
220 #if defined(_USE_OPENSSL_)
221     .encryptResult = HKS_SUCCESS,
222 #endif
223 #if defined(_USE_MBEDTLS_)
224     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
225 #endif
226 };
227 #endif
228 
229 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS = {
230     .usageSpec = {
231         .algType = HKS_ALG_AES,
232         .mode = HKS_MODE_GCM,
233         .padding = HKS_PADDING_NONE,
234         .digest = HKS_DIGEST_NONE,
235         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
236         .algParam = &AEAD_PARAM,
237     },
238     .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088",
239     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
240 
241     .encryptResult = HKS_SUCCESS,
242 };
243 
244 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS = {
245     .usageSpec = {
246         .algType = HKS_ALG_AES,
247         .mode = HKS_MODE_CBC,
248         .padding = HKS_PADDING_NONE,
249         .digest = HKS_DIGEST_NONE,
250         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
251         .algParam = &TAG_IV,
252     },
253     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
254     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
255 
256     .encryptResult = HKS_SUCCESS,
257 };
258 
259 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS = {
260     .usageSpec = {
261         .algType = HKS_ALG_AES,
262         .mode = HKS_MODE_CBC,
263         .padding = HKS_PADDING_PKCS7,
264         .digest = HKS_DIGEST_NONE,
265         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
266         .algParam = &TAG_IV,
267     },
268     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
269     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
270 
271     .encryptResult = HKS_SUCCESS,
272 };
273 
274 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS = {
275     .usageSpec = {
276         .algType = HKS_ALG_AES,
277         .mode = HKS_MODE_CTR,
278         .padding = HKS_PADDING_NONE,
279         .digest = HKS_DIGEST_NONE,
280         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
281         .algParam = &TAG_IV,
282     },
283     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
284     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
285 
286     .encryptResult = HKS_SUCCESS,
287 };
288 
289 #ifdef HKS_UNTRUSTED_RUNNING_ENV
290 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS = {
291     .usageSpec = {
292         .algType = HKS_ALG_AES,
293         .mode = HKS_MODE_ECB,
294         .padding = HKS_PADDING_NONE,
295         .digest = HKS_DIGEST_NONE,
296         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
297         .algParam = nullptr,
298     },
299     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
300     .hexData = "00112233445566778899aabbccddeeff",
301 
302     .encryptResult = HKS_SUCCESS,
303 };
304 
305 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS = {
306     .usageSpec = {
307         .algType = HKS_ALG_AES,
308         .mode = HKS_MODE_ECB,
309         .padding = HKS_PADDING_PKCS7,
310         .digest = HKS_DIGEST_NONE,
311         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
312         .algParam = nullptr,
313     },
314     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
315     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
316 #if defined(_USE_OPENSSL_)
317     .encryptResult = HKS_SUCCESS,
318 #endif
319 #if defined(_USE_MBEDTLS_)
320     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
321 #endif
322 };
323 #endif
324 
325 const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS = {
326     .usageSpec = {
327         .algType = HKS_ALG_AES,
328         .mode = HKS_MODE_GCM,
329         .padding = HKS_PADDING_NONE,
330         .digest = HKS_DIGEST_NONE,
331         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
332         .algParam = &AEAD_PARAM,
333     },
334     .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f",
335     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
336 
337     .encryptResult = HKS_SUCCESS,
338 };
339 }  // namespace
340 
341 class HksCryptoHalAesEncrypt : public HksCryptoHalCommon, public testing::Test {
342 public:
343     static void SetUpTestCase(void);
344     static void TearDownTestCase(void);
345     void SetUp();
346     void TearDown();
347 protected:
RunTestEncrypt(struct HksBlob * key,const TestCaseParams & testCaseParams,struct HksBlob * encryptMsg,struct HksBlob * encryptOut,struct HksBlob * tagAead) const348     void RunTestEncrypt(struct HksBlob *key, const TestCaseParams &testCaseParams, struct HksBlob *encryptMsg,
349         struct HksBlob *encryptOut, struct HksBlob *tagAead) const
350     {
351         void *encryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
352         ASSERT_EQ(encryptCtx == nullptr, false) << "encryptCtx malloc failed.";
353         uint32_t inLen = encryptMsg->size;
354 
355         EXPECT_EQ(HksCryptoHalEncryptInit(key, &testCaseParams.usageSpec, &encryptCtx), testCaseParams.encryptResult);
356         if (testCaseParams.encryptResult != HKS_SUCCESS) {
357             return;
358         }
359         uint32_t point = 0;
360         if (inLen > HKS_UPDATE_DATA_MAX) {
361             HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
362             HksBlob out = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
363             ASSERT_EQ(messageUpdate.data == nullptr, false) << "messageUpdate malloc failed.";
364             ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
365 
366             while (point < inLen - HKS_UPDATE_DATA_MAX) {
367                 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size,
368                     (encryptMsg->data + point), HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
369                 EXPECT_EQ(HksCryptoHalEncryptUpdate(&messageUpdate, encryptCtx, &out, testCaseParams.usageSpec.algType),
370                     testCaseParams.encryptResult) << "HksCryptoHalEncryptUpdate failed.";
371                 point = point + HKS_UPDATE_DATA_MAX;
372             }
373             HKS_FREE(out.data);
374             HKS_FREE(messageUpdate.data);
375 
376             uint32_t lastLen = inLen - point;
377             HksBlob enMessageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
378             HksBlob enMessageLastOut = {
379                 .size = HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT,
380                 .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT)
381             };
382             ASSERT_EQ(enMessageLast.data == nullptr, false) << "enMessageLast malloc failed.";
383             ASSERT_EQ(enMessageLastOut.data == nullptr, false) << "enMessageLastOut malloc failed.";
384             (void)memcpy_s(enMessageLast.data, lastLen, (encryptMsg->data + point), lastLen);
385             EXPECT_EQ(HksCryptoHalEncryptFinal(&enMessageLast, &encryptCtx, &enMessageLastOut, tagAead,
386                 testCaseParams.usageSpec.algType), testCaseParams.encryptResult) << "HksCryptoHalEncryptFinal failed.";
387 
388             HKS_FREE(enMessageLast.data);
389             HKS_FREE(enMessageLastOut.data);
390         } else {
391             HksBlob out = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
392             ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
393             EXPECT_EQ(HksCryptoHalEncryptUpdate(encryptMsg, encryptCtx, &out, testCaseParams.usageSpec.algType),
394                 testCaseParams.encryptResult) << "HksCryptoHalEncryptUpdate failed.";
395             HKS_FREE(out.data);
396 
397             HksBlob enMessageLast = { .size = 0, .data = nullptr };
398             EXPECT_EQ(HksCryptoHalEncryptFinal(&enMessageLast, &encryptCtx, encryptOut, tagAead,
399                 testCaseParams.usageSpec.algType), testCaseParams.encryptResult) << "HksCryptoHalEncryptFinal failed.";
400         }
401     }
402 
RunTestCase(const TestCaseParams & testCaseParams) const403     void RunTestCase(const TestCaseParams &testCaseParams) const
404     {
405         uint32_t keyLen = testCaseParams.keyData.length() / HKS_COUNT_OF_HALF;
406         HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) };
407         ASSERT_EQ(key.data == nullptr, false) << "key malloc failed.";
408         for (uint32_t ii = 0; ii < keyLen; ii++) {
409             key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[HKS_COUNT_OF_HALF * ii]);
410         }
411 
412         uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
413         uint32_t outLen = inLen;
414         if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) {
415             outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT;
416         }
417         HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
418         ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
419         for (uint32_t ii = 0; ii < inLen; ii++) {
420             message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
421         }
422         HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) };
423         HksBlob tagAead = { .size = AEAD_SIZE, .data = (uint8_t *)HksMalloc(AEAD_SIZE) };
424         ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
425         ASSERT_EQ(tagAead.data == nullptr, false) << "tagAead malloc failed.";
426 
427         if (testCaseParams.runStage == HksStageType::HKS_STAGE_THREE) {
428             RunTestEncrypt(&key, testCaseParams, &message, &cipherText, &tagAead);
429         } else {
430             EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead),
431                 testCaseParams.encryptResult);
432         }
433 
434         HKS_FREE(key.data);
435         HKS_FREE(message.data);
436         HKS_FREE(cipherText.data);
437         HKS_FREE(tagAead.data);
438     }
439 };
440 
SetUpTestCase(void)441 void HksCryptoHalAesEncrypt::SetUpTestCase(void)
442 {
443 }
444 
TearDownTestCase(void)445 void HksCryptoHalAesEncrypt::TearDownTestCase(void)
446 {
447 }
448 
SetUp()449 void HksCryptoHalAesEncrypt::SetUp()
450 {
451     EXPECT_EQ(HksCryptoAbilityInit(), 0);
452 }
453 
TearDown()454 void HksCryptoHalAesEncrypt::TearDown()
455 {
456 }
457 
458 /**
459  * @tc.number    : HksCryptoHalAesEncrypt_001
460  * @tc.name      : HksCryptoHalAesEncrypt_001
461  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-NOPADDING key.
462  */
463 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTest | Level0)
464 {
465     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS);
466 }
467 
468 /**
469  * @tc.number    : HksCryptoHalAesEncrypt_002
470  * @tc.name      : HksCryptoHalAesEncrypt_002
471  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-PKCS7PADDING key.
472  */
473 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTest | Level0)
474 {
475     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS);
476 }
477 
478 /**
479  * @tc.number    : HksCryptoHalAesEncrypt_003
480  * @tc.name      : HksCryptoHalAesEncrypt_003
481  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-CTR-NOPADDING key.
482  */
483 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTest | Level0)
484 {
485     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS);
486 }
487 
488 #ifdef HKS_UNTRUSTED_RUNNING_ENV
489 /**
490  * @tc.number    : HksCryptoHalAesEncrypt_004
491  * @tc.name      : HksCryptoHalAesEncrypt_004
492  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-NOPADDING key.
493  */
494 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTest | Level0)
495 {
496     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS);
497 }
498 
499 /**
500  * @tc.number    : HksCryptoHalAesEncrypt_005
501  * @tc.name      : HksCryptoHalAesEncrypt_005
502  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-PKCS7PADDING key.
503  */
504 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTest | Level0)
505 {
506     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS);
507 }
508 
509 /**
510  * @tc.number    : HksCryptoHalAesEncrypt_010
511  * @tc.name      : HksCryptoHalAesEncrypt_010
512  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-NOPADDING key.
513  */
514 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTest | Level0)
515 {
516     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS);
517 }
518 
519 /**
520  * @tc.number    : HksCryptoHalAesEncrypt_011
521  * @tc.name      : HksCryptoHalAesEncrypt_011
522  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-PKCS7PADDING key.
523  */
524 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTest | Level0)
525 {
526     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS);
527 }
528 
529 
530 /**
531  * @tc.number    : HksCryptoHalAesEncrypt_016
532  * @tc.name      : HksCryptoHalAesEncrypt_016
533  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-NOPADDING key.
534  */
535 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTest | Level0)
536 {
537     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS);
538 }
539 
540 /**
541  * @tc.number    : HksCryptoHalAesEncrypt_017
542  * @tc.name      : HksCryptoHalAesEncrypt_017
543  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-PKCS7PADDING key.
544  */
545 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTest | Level0)
546 {
547     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS);
548 }
549 #endif
550 /**
551  * @tc.number    : HksCryptoHalAesEncrypt_006
552  * @tc.name      : HksCryptoHalAesEncrypt_006
553  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-128-GCM-NOPADDING key.
554  */
555 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTest | Level0)
556 {
557     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS);
558 }
559 
560 /**
561  * @tc.number    : HksCryptoHalAesEncrypt_007
562  * @tc.name      : HksCryptoHalAesEncrypt_007
563  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-NOPADDING key.
564  */
565 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTest | Level0)
566 {
567     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS);
568 }
569 
570 /**
571  * @tc.number    : HksCryptoHalAesEncrypt_008
572  * @tc.name      : HksCryptoHalAesEncrypt_008
573  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-PKCS7PADDING key.
574  */
575 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTest | Level0)
576 {
577     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS);
578 }
579 
580 /**
581  * @tc.number    : HksCryptoHalAesEncrypt_009
582  * @tc.name      : HksCryptoHalAesEncrypt_009
583  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-CTR-NOPADDING key.
584  */
585 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTest | Level0)
586 {
587     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS);
588 }
589 
590 
591 /**
592  * @tc.number    : HksCryptoHalAesEncrypt_012
593  * @tc.name      : HksCryptoHalAesEncrypt_012
594  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-192-GCM-NOPADDING key.
595  */
596 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTest | Level0)
597 {
598     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS);
599 }
600 
601 /**
602  * @tc.number    : HksCryptoHalAesEncrypt_013
603  * @tc.name      : HksCryptoHalAesEncrypt_013
604  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-NOPADDING key.
605  */
606 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTest | Level0)
607 {
608     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS);
609 }
610 
611 /**
612  * @tc.number    : HksCryptoHalAesEncrypt_014
613  * @tc.name      : HksCryptoHalAesEncrypt_014
614  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-PKCS7PADDING key.
615  */
616 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTest | Level0)
617 {
618     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS);
619 }
620 
621 /**
622  * @tc.number    : HksCryptoHalAesEncrypt_015
623  * @tc.name      : HksCryptoHalAesEncrypt_015
624  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-CTR-NOPADDING key.
625  */
626 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTest | Level0)
627 {
628     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS);
629 }
630 
631 /**
632  * @tc.number    : HksCryptoHalAesEncrypt_018
633  * @tc.name      : HksCryptoHalAesEncrypt_018
634  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt AES-256-GCM-NOPADDING key.
635  */
636 HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTest | Level0)
637 {
638     RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS);
639 }
640 }  // namespace UnitTest
641 }  // namespace Huks
642 }  // namespace Security
643 }  // namespace OHOS