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