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