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 <securec.h>
17 #include <string>
18
19 #include <gtest/gtest.h>
20
21 #include "file_ex.h"
22 #include "hks_ability.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 HksKeySpec spec = {0};
35 HksUsageSpec usageSpec = {0};
36 std::string hexData;
37
38 HksErrorCode generateKeyResult = HksErrorCode::HKS_SUCCESS;
39 HksErrorCode encryptResult = HksErrorCode::HKS_SUCCESS;
40 HksErrorCode decryptResult = HksErrorCode::HKS_SUCCESS;
41 };
42
43 const uint32_t IV_SIZE = 16;
44 const uint32_t AEAD_SIZE = 16;
45 const uint8_t IV[IV_SIZE] = {0};
46 const HksCipherParam TAG_IV = { .iv = { .size = IV_SIZE, .data = (uint8_t *)IV } };
47 const HksAeadParam AEAD_PARAM = {
48 .nonce = { .size = IV_SIZE, .data = (uint8_t *)IV },
49 .aad = { .size = 0, .data = nullptr },
50 .tagLenEnc = IV_SIZE,
51 .payloadLen = 0,
52 };
53
54 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS = {
55 .spec = {
56 .algType = HKS_ALG_AES,
57 .keyLen = HKS_AES_KEY_SIZE_128,
58 .algParam = nullptr,
59 },
60 .usageSpec = {
61 .algType = HKS_ALG_AES,
62 .mode = HKS_MODE_CBC,
63 .padding = HKS_PADDING_NONE,
64 .digest = HKS_DIGEST_NONE,
65 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
66 .algParam = (void *)&TAG_IV,
67 },
68 .hexData =
69 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
70 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
71 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
72 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
73 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
74 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
75 "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
76
77 .generateKeyResult = HKS_SUCCESS,
78 .encryptResult = HKS_SUCCESS,
79 .decryptResult = HKS_SUCCESS,
80 };
81
82 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS = {
83 .spec = {
84 .algType = HKS_ALG_AES,
85 .keyLen = HKS_AES_KEY_SIZE_128,
86 .algParam = nullptr,
87 },
88 .usageSpec = {
89 .algType = HKS_ALG_AES,
90 .mode = HKS_MODE_CBC,
91 .padding = HKS_PADDING_PKCS7,
92 .digest = HKS_DIGEST_NONE,
93 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
94 .algParam = (void *)&TAG_IV,
95 },
96 .hexData =
97 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
98 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
99
100 .generateKeyResult = HKS_SUCCESS,
101 .encryptResult = HKS_SUCCESS,
102 .decryptResult = HKS_SUCCESS,
103 };
104
105 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS = {
106 .spec = {
107 .algType = HKS_ALG_AES,
108 .keyLen = HKS_AES_KEY_SIZE_128,
109 .algParam = nullptr,
110 },
111 .usageSpec = {
112 .algType = HKS_ALG_AES,
113 .mode = HKS_MODE_CTR,
114 .padding = HKS_PADDING_NONE,
115 .digest = HKS_DIGEST_NONE,
116 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
117 .algParam = (void *)&TAG_IV,
118 },
119 .hexData =
120 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
121 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
122
123 .generateKeyResult = HKS_SUCCESS,
124 .encryptResult = HKS_SUCCESS,
125 .decryptResult = HKS_SUCCESS,
126 };
127
128 #ifdef HKS_UNTRUSTED_RUNNING_ENV
129 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS = {
130 .spec = {
131 .algType = HKS_ALG_AES,
132 .keyLen = HKS_AES_KEY_SIZE_128,
133 .algParam = nullptr,
134 },
135 .usageSpec = {
136 .algType = HKS_ALG_AES,
137 .mode = HKS_MODE_ECB,
138 .padding = HKS_PADDING_NONE,
139 .digest = HKS_DIGEST_NONE,
140 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
141 .algParam = nullptr,
142 },
143 .hexData = "00112233445566778899aabbccddeeff",
144
145 .generateKeyResult = HKS_SUCCESS,
146 .encryptResult = HKS_SUCCESS,
147 .decryptResult = HKS_SUCCESS,
148 };
149
150 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS = {
151 .spec = {
152 .algType = HKS_ALG_AES,
153 .keyLen = HKS_AES_KEY_SIZE_128,
154 .algParam = nullptr,
155 },
156 .usageSpec = {
157 .algType = HKS_ALG_AES,
158 .mode = HKS_MODE_ECB,
159 .padding = HKS_PADDING_PKCS7,
160 .digest = HKS_DIGEST_NONE,
161 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
162 .algParam = nullptr,
163 },
164 .hexData =
165 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
166 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
167
168 .generateKeyResult = HKS_SUCCESS,
169 #if defined(_USE_OPENSSL_)
170 .encryptResult = HKS_SUCCESS,
171 .decryptResult = HKS_SUCCESS,
172 #endif
173 #if defined(_USE_MBEDTLS_)
174 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
175 #endif
176 };
177 #endif
178
179 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS = {
180 .spec = {
181 .algType = HKS_ALG_AES,
182 .keyLen = HKS_AES_KEY_SIZE_128,
183 .algParam = nullptr,
184 },
185 .usageSpec = {
186 .algType = HKS_ALG_AES,
187 .mode = HKS_MODE_GCM,
188 .padding = HKS_PADDING_NONE,
189 .digest = HKS_DIGEST_NONE,
190 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
191 .algParam = (void *)&AEAD_PARAM,
192 },
193 .hexData =
194 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
195 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
196 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
197 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
198 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
199 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
200 "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
201
202 .generateKeyResult = HKS_SUCCESS,
203 .encryptResult = HKS_SUCCESS,
204 .decryptResult = HKS_SUCCESS,
205 };
206
207 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS = {
208 .spec = {
209 .algType = HKS_ALG_AES,
210 .keyLen = HKS_AES_KEY_SIZE_192,
211 .algParam = nullptr,
212 },
213 .usageSpec = {
214 .algType = HKS_ALG_AES,
215 .mode = HKS_MODE_CBC,
216 .padding = HKS_PADDING_NONE,
217 .digest = HKS_DIGEST_NONE,
218 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
219 .algParam = (void *)&TAG_IV,
220 },
221 .hexData =
222 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
223 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
224
225 .generateKeyResult = HKS_SUCCESS,
226 .encryptResult = HKS_SUCCESS,
227 .decryptResult = HKS_SUCCESS,
228 };
229
230 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS = {
231 .spec = {
232 .algType = HKS_ALG_AES,
233 .keyLen = HKS_AES_KEY_SIZE_192,
234 .algParam = nullptr,
235 },
236 .usageSpec = {
237 .algType = HKS_ALG_AES,
238 .mode = HKS_MODE_CBC,
239 .padding = HKS_PADDING_PKCS7,
240 .digest = HKS_DIGEST_NONE,
241 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
242 .algParam = (void *)&TAG_IV,
243 },
244 .hexData =
245 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
246 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
247
248 .generateKeyResult = HKS_SUCCESS,
249 .encryptResult = HKS_SUCCESS,
250 .decryptResult = HKS_SUCCESS,
251 };
252
253 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS = {
254 .spec = {
255 .algType = HKS_ALG_AES,
256 .keyLen = HKS_AES_KEY_SIZE_192,
257 .algParam = nullptr,
258 },
259 .usageSpec = {
260 .algType = HKS_ALG_AES,
261 .mode = HKS_MODE_CTR,
262 .padding = HKS_PADDING_NONE,
263 .digest = HKS_DIGEST_NONE,
264 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
265 .algParam = (void *)&TAG_IV,
266 },
267 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
268
269 .generateKeyResult = HKS_SUCCESS,
270 .encryptResult = HKS_SUCCESS,
271 .decryptResult = HKS_SUCCESS,
272 };
273
274 #ifdef HKS_UNTRUSTED_RUNNING_ENV
275 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS = {
276 .spec = {
277 .algType = HKS_ALG_AES,
278 .keyLen = HKS_AES_KEY_SIZE_192,
279 .algParam = nullptr,
280 },
281 .usageSpec = {
282 .algType = HKS_ALG_AES,
283 .mode = HKS_MODE_ECB,
284 .padding = HKS_PADDING_NONE,
285 .digest = HKS_DIGEST_NONE,
286 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
287 .algParam = nullptr,
288 },
289 .hexData = "00112233445566778899aabbccddeeff",
290
291 .generateKeyResult = HKS_SUCCESS,
292 .encryptResult = HKS_SUCCESS,
293 .decryptResult = HKS_SUCCESS,
294 };
295
296 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS = {
297 .spec = {
298 .algType = HKS_ALG_AES,
299 .keyLen = HKS_AES_KEY_SIZE_192,
300 .algParam = nullptr,
301 },
302 .usageSpec = {
303 .algType = HKS_ALG_AES,
304 .mode = HKS_MODE_ECB,
305 .padding = HKS_PADDING_PKCS7,
306 .digest = HKS_DIGEST_NONE,
307 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
308 .algParam = nullptr,
309 },
310 .hexData =
311 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
312 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
313
314 .generateKeyResult = HKS_SUCCESS,
315 #if defined(_USE_OPENSSL_)
316 .encryptResult = HKS_SUCCESS,
317 .decryptResult = 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_CIPHER_012_PARAMS = {
326 .spec = {
327 .algType = HKS_ALG_AES,
328 .keyLen = HKS_AES_KEY_SIZE_192,
329 .algParam = nullptr,
330 },
331 .usageSpec = {
332 .algType = HKS_ALG_AES,
333 .mode = HKS_MODE_GCM,
334 .padding = HKS_PADDING_NONE,
335 .digest = HKS_DIGEST_NONE,
336 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
337 .algParam = (void *)&AEAD_PARAM,
338 },
339 .hexData =
340 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
341 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
342
343 .generateKeyResult = HKS_SUCCESS,
344 .encryptResult = HKS_SUCCESS,
345 .decryptResult = HKS_SUCCESS,
346 };
347
348 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS = {
349 .spec = {
350 .algType = HKS_ALG_AES,
351 .keyLen = HKS_AES_KEY_SIZE_256,
352 .algParam = nullptr,
353 },
354 .usageSpec = {
355 .algType = HKS_ALG_AES,
356 .mode = HKS_MODE_CBC,
357 .padding = HKS_PADDING_NONE,
358 .digest = HKS_DIGEST_NONE,
359 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
360 .algParam = (void *)&TAG_IV,
361 },
362 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
363
364 .generateKeyResult = HKS_SUCCESS,
365 .encryptResult = HKS_SUCCESS,
366 .decryptResult = HKS_SUCCESS,
367 };
368
369 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS = {
370 .spec = {
371 .algType = HKS_ALG_AES,
372 .keyLen = HKS_AES_KEY_SIZE_256,
373 .algParam = nullptr,
374 },
375 .usageSpec = {
376 .algType = HKS_ALG_AES,
377 .mode = HKS_MODE_CBC,
378 .padding = HKS_PADDING_PKCS7,
379 .digest = HKS_DIGEST_NONE,
380 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
381 .algParam = (void *)&TAG_IV,
382 },
383 .hexData =
384 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
385 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
386
387 .generateKeyResult = HKS_SUCCESS,
388 .encryptResult = HKS_SUCCESS,
389 .decryptResult = HKS_SUCCESS,
390 };
391
392 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS = {
393 .spec = {
394 .algType = HKS_ALG_AES,
395 .keyLen = HKS_AES_KEY_SIZE_256,
396 .algParam = nullptr,
397 },
398 .usageSpec = {
399 .algType = HKS_ALG_AES,
400 .mode = HKS_MODE_CTR,
401 .padding = HKS_PADDING_NONE,
402 .digest = HKS_DIGEST_NONE,
403 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
404 .algParam = (void *)&TAG_IV,
405 },
406 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
407
408 .generateKeyResult = HKS_SUCCESS,
409 .encryptResult = HKS_SUCCESS,
410 .decryptResult = HKS_SUCCESS,
411 };
412
413 #ifdef HKS_UNTRUSTED_RUNNING_ENV
414 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS = {
415 .spec = {
416 .algType = HKS_ALG_AES,
417 .keyLen = HKS_AES_KEY_SIZE_256,
418 .algParam = nullptr,
419 },
420 .usageSpec = {
421 .algType = HKS_ALG_AES,
422 .mode = HKS_MODE_ECB,
423 .padding = HKS_PADDING_NONE,
424 .digest = HKS_DIGEST_NONE,
425 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
426 .algParam = nullptr,
427 },
428 .hexData = "00112233445566778899aabbccddeeff",
429
430 .generateKeyResult = HKS_SUCCESS,
431 .encryptResult = HKS_SUCCESS,
432 .decryptResult = HKS_SUCCESS,
433 };
434
435 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS = {
436 .spec = {
437 .algType = HKS_ALG_AES,
438 .keyLen = HKS_AES_KEY_SIZE_256,
439 .algParam = nullptr,
440 },
441 .usageSpec = {
442 .algType = HKS_ALG_AES,
443 .mode = HKS_MODE_ECB,
444 .padding = HKS_PADDING_PKCS7,
445 .digest = HKS_DIGEST_NONE,
446 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
447 .algParam = nullptr,
448 },
449 .hexData =
450 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
451 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
452
453 .generateKeyResult = HKS_SUCCESS,
454 #if defined(_USE_OPENSSL_)
455 .encryptResult = HKS_SUCCESS,
456 .decryptResult = HKS_SUCCESS,
457 #endif
458 #if defined(_USE_MBEDTLS_)
459 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
460 #endif
461 };
462 #endif
463
464 const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS = {
465 .spec = {
466 .algType = HKS_ALG_AES,
467 .keyLen = HKS_AES_KEY_SIZE_256,
468 .algParam = nullptr,
469 },
470 .usageSpec = {
471 .algType = HKS_ALG_AES,
472 .mode = HKS_MODE_GCM,
473 .padding = HKS_PADDING_NONE,
474 .digest = HKS_DIGEST_NONE,
475 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
476 .algParam = (void *)&AEAD_PARAM,
477 },
478 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
479
480 .generateKeyResult = HKS_SUCCESS,
481 .encryptResult = HKS_SUCCESS,
482 .decryptResult = HKS_SUCCESS,
483 };
484 } // namespace
485
486 class HksCryptoHalAesCipher : public HksCryptoHalCommon, public testing::Test {
487 public:
488 static void SetUpTestCase(void);
489 static void TearDownTestCase(void);
490 void SetUp();
491 void TearDown();
492 protected:
RunTestEncrypt(struct HksBlob * key,const TestCaseParams & testCaseParams,struct HksBlob * encryptMsg,struct HksBlob * encryptOut,struct HksBlob * tagAead)493 void RunTestEncrypt(struct HksBlob *key, const TestCaseParams &testCaseParams, struct HksBlob *encryptMsg,
494 struct HksBlob *encryptOut, struct HksBlob *tagAead)
495 {
496 void *encryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
497 ASSERT_EQ(encryptCtx == nullptr, false) << "encryptCtx malloc failed.";
498 uint32_t inLen = encryptMsg->size;
499
500 EXPECT_EQ(HksCryptoHalEncryptInit(key, &testCaseParams.usageSpec, &encryptCtx), testCaseParams.encryptResult);
501 if (testCaseParams.encryptResult != HKS_SUCCESS) {
502 return;
503 }
504
505 uint32_t point = 0;
506 uint32_t outPoint = 0;
507 if (inLen > HKS_UPDATE_DATA_MAX) {
508 HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
509 HksBlob out = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
510 ASSERT_EQ(messageUpdate.data == nullptr || out.data == nullptr, false) << "malloc failed.";
511
512 while (point < inLen - HKS_UPDATE_DATA_MAX) {
513 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size,
514 (encryptMsg->data + point), HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
515 EXPECT_EQ(HksCryptoHalEncryptUpdate(&messageUpdate, encryptCtx, &out, testCaseParams.usageSpec.algType),
516 testCaseParams.encryptResult) << "HksCryptoHalEncryptUpdate failed.";
517
518 (void)memcpy_s((encryptOut->data + outPoint), out.size, out.data, out.size);
519 encryptOut->size += out.size;
520 point = point + HKS_UPDATE_DATA_MAX;
521 outPoint = outPoint + out.size;
522 }
523 HKS_FREE(out.data);
524 HKS_FREE(messageUpdate.data);
525
526 uint32_t lastLen = inLen - point;
527 uint32_t lastOutLen = HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT;
528 HksBlob enMessageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
529 HksBlob enMessageLastOut = { .size = lastOutLen, .data = (uint8_t *)HksMalloc(lastOutLen) };
530 ASSERT_EQ(enMessageLast.data == nullptr || enMessageLastOut.data == nullptr, false) << "msg malloc failed.";
531 (void)memcpy_s(enMessageLast.data, lastLen, (encryptMsg->data + point), lastLen);
532 EXPECT_EQ(HksCryptoHalEncryptFinal(&enMessageLast, &encryptCtx, &enMessageLastOut, tagAead,
533 testCaseParams.usageSpec.algType), testCaseParams.encryptResult) << "HksCryptoHalEncryptFinal failed.";
534 (void)memcpy_s((encryptOut->data + outPoint), enMessageLastOut.size, enMessageLastOut.data,
535 enMessageLastOut.size);
536 encryptOut->size += enMessageLastOut.size;
537 HKS_FREE(enMessageLast.data);
538 } else {
539 HksBlob out = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
540 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
541 EXPECT_EQ(HksCryptoHalEncryptUpdate(encryptMsg, encryptCtx, &out, testCaseParams.usageSpec.algType),
542 testCaseParams.encryptResult) << "HksCryptoHalEncryptUpdate failed.";
543 (void)memcpy_s((encryptOut->data), out.size, out.data, out.size);
544 encryptOut->size = out.size;
545
546 HksBlob enMessageLast = { .size = 0, .data = nullptr };
547 HksBlob enMessageLastOut = { .size = 0, .data = nullptr };
548 EXPECT_EQ(HksCryptoHalEncryptFinal(&enMessageLast, &encryptCtx, &enMessageLastOut, tagAead,
549 testCaseParams.usageSpec.algType), testCaseParams.encryptResult) << "HksCryptoHalEncryptFinal failed.";
550 HKS_FREE(out.data);
551 }
552 }
553
RunTestDecrypt(const TestCaseParams & testCaseParams,struct HksBlob * key,struct HksBlob * decryptMsg,struct HksBlob * tagAead,struct HksBlob * decryptOut)554 void RunTestDecrypt(const TestCaseParams &testCaseParams, struct HksBlob *key, struct HksBlob *decryptMsg,
555 struct HksBlob *tagAead, struct HksBlob *decryptOut)
556 {
557 void* decryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
558 ASSERT_EQ(decryptCtx == nullptr, false) << "decryptCtx malloc failed.";
559 EXPECT_EQ(HksCryptoHalDecryptInit(key, &testCaseParams.usageSpec, &decryptCtx), testCaseParams.decryptResult);
560 uint32_t decrytopoint = 0;
561 uint32_t decrytooutPoint = 0;
562 uint32_t decrytoinLen = decryptMsg->size;
563 if (decrytoinLen > HKS_UPDATE_DATA_MAX) {
564 HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
565 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
566 ASSERT_EQ(messageUpdate.data == nullptr || out.data == nullptr, false) << "malloc failed.";
567 while (decrytopoint < decrytoinLen - HKS_UPDATE_DATA_MAX) {
568 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size, (decryptMsg->data + decrytopoint),
569 HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
570 EXPECT_EQ(HksCryptoHalDecryptUpdate(&messageUpdate, decryptCtx, &out, testCaseParams.usageSpec.algType),
571 testCaseParams.decryptResult);
572 (void)memcpy_s((decryptOut->data + decrytooutPoint), out.size, out.data, out.size);
573 decryptOut->size += out.size;
574 decrytopoint = decrytopoint + HKS_UPDATE_DATA_MAX;
575 decrytooutPoint = decrytooutPoint + out.size;
576 }
577 HKS_FREE(out.data);
578 HKS_FREE(messageUpdate.data);
579
580 uint32_t lastLen = decrytoinLen - decrytopoint;
581 HksBlob messageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
582 HksBlob messageLastOut = {
583 .size = HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT,
584 .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT)
585 };
586 ASSERT_EQ(messageLast.data == nullptr || messageLastOut.data == nullptr, false) << "message malloc failed.";
587
588 (void)memcpy_s(messageLast.data, lastLen, (decryptMsg->data + decrytopoint), lastLen);
589 EXPECT_EQ(HksCryptoHalDecryptFinal(&messageLast, &decryptCtx, &messageLastOut, tagAead,
590 testCaseParams.usageSpec.algType), testCaseParams.decryptResult) << "HksCryptoHalEncryptFinal failed.";
591 (void)memcpy_s((decryptOut->data + decrytooutPoint), messageLastOut.size, messageLastOut.data,
592 messageLastOut.size);
593 decryptOut->size += messageLastOut.size;
594
595 HKS_FREE(messageLast.data);
596 } else {
597 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
598 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
599 EXPECT_EQ(HksCryptoHalDecryptUpdate(decryptMsg, decryptCtx, &out,
600 testCaseParams.usageSpec.algType), testCaseParams.decryptResult);
601 (void)memcpy_s((decryptOut->data), out.size, out.data, out.size);
602 decryptOut->size = out.size;
603
604 HksBlob deMessageLast = { .size = 0, .data = nullptr };
605 HksBlob messageLastOut = { .size = 0, .data = nullptr };
606 EXPECT_EQ(HksCryptoHalDecryptFinal(&deMessageLast, &decryptCtx, &messageLastOut, tagAead,
607 testCaseParams.usageSpec.algType), testCaseParams.decryptResult);
608
609 HKS_FREE(deMessageLast.data);
610 HKS_FREE(out.data);
611 }
612 }
613
RunTestCaseThreeStage(const TestCaseParams & testCaseParams)614 void RunTestCaseThreeStage(const TestCaseParams &testCaseParams)
615 {
616 HksBlob key = { .size = 0, .data = nullptr };
617
618 uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
619 uint32_t outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT;
620
621 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
622 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
623 for (uint32_t ii = 0; ii < inLen; ii++) {
624 message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
625 }
626
627 HksBlob tagAead = { .size = AEAD_SIZE, .data = (uint8_t *)HksMalloc(AEAD_SIZE) };
628 HksBlob encryptAll = { .size = 0, .data = (uint8_t *)HksMalloc(outLen) };
629 HksBlob decryptAll = { .size = 0, .data = (uint8_t *)HksMalloc(outLen) };
630 ASSERT_EQ(tagAead.data == nullptr || encryptAll.data == nullptr ||
631 decryptAll.data == nullptr, false) << "malloc failed.";
632
633 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
634
635 RunTestEncrypt(&key, testCaseParams, &message, &encryptAll, &tagAead);
636
637 if (testCaseParams.encryptResult == HKS_SUCCESS) {
638 RunTestDecrypt(testCaseParams, &key, &encryptAll, &tagAead, &decryptAll);
639 EXPECT_EQ(message.size, decryptAll.size) << "compare size failed.";
640 EXPECT_EQ(HksMemCmp(message.data, decryptAll.data, decryptAll.size), HKS_SUCCESS) << "compare data failed.";
641 }
642
643 HKS_FREE(encryptAll.data);
644 HKS_FREE(decryptAll.data);
645 HKS_FREE(key.data);
646 HKS_FREE(tagAead.data);
647 }
648
RunTestGcmDecrypt(const HksUsageSpec & usageSpec,struct HksBlob * key,struct HksBlob * decryptMsg,struct HksBlob * tagAead,struct HksBlob * decryptOut)649 void RunTestGcmDecrypt(const HksUsageSpec &usageSpec, struct HksBlob *key, struct HksBlob *decryptMsg,
650 struct HksBlob *tagAead, struct HksBlob *decryptOut)
651 {
652 void* decryptCtx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
653 ASSERT_EQ(decryptCtx == nullptr, false) << "decryptCtx malloc failed.";
654 EXPECT_EQ(HksCryptoHalDecryptInit(key, &usageSpec, &decryptCtx), HKS_SUCCESS);
655 uint32_t decrytopoint = 0;
656 uint32_t decrytooutPoint = 0;
657 uint32_t decrytoinLen = decryptMsg->size;
658
659 if (decrytoinLen > HKS_UPDATE_DATA_MAX) {
660 HksBlob messageUpdate = { .size = HKS_UPDATE_DATA_MAX, .data = (uint8_t *)HksMalloc(HKS_UPDATE_DATA_MAX) };
661 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
662 ASSERT_EQ(messageUpdate.data == nullptr || out.data == nullptr, false) << "malloc failed.";
663 while (decrytopoint < decrytoinLen - HKS_UPDATE_DATA_MAX) {
664 EXPECT_EQ(memcpy_s(messageUpdate.data, messageUpdate.size, (decryptMsg->data + decrytopoint),
665 HKS_UPDATE_DATA_MAX), EOK) << "memcpy fail";
666 EXPECT_EQ(HksCryptoHalDecryptUpdate(&messageUpdate, decryptCtx, &out,
667 usageSpec.algType), HKS_SUCCESS);
668 (void)memcpy_s((decryptOut->data + decrytooutPoint), out.size, out.data, out.size);
669 decryptOut->size += out.size;
670 decrytopoint = decrytopoint + HKS_UPDATE_DATA_MAX;
671 decrytooutPoint = decrytooutPoint + out.size;
672 }
673 HKS_FREE(out.data);
674 HKS_FREE(messageUpdate.data);
675
676 uint32_t lastLen = decrytoinLen - decrytopoint;
677 uint32_t lastOutLen = HKS_UPDATE_DATA_MAX + HKS_PADDING_SUPPLENMENT;
678 HksBlob messageLast = { .size = lastLen, .data = (uint8_t *)HksMalloc(lastLen) };
679 HksBlob messageLastOut = { .size = lastOutLen, .data = (uint8_t *)HksMalloc(lastOutLen) };
680 ASSERT_EQ(messageLast.data == nullptr || messageLastOut.data == nullptr, false) << "message malloc failed.";
681 (void)memcpy_s(messageLast.data, lastLen, (decryptMsg->data + decrytopoint), lastLen);
682 EXPECT_EQ(HksCryptoHalDecryptFinal(&messageLast, &decryptCtx, &messageLastOut, tagAead,
683 usageSpec.algType), HKS_SUCCESS) << "HksCryptoHalEncryptFinal failed.";
684 (void)memcpy_s((decryptOut->data + decrytooutPoint), messageLastOut.size, messageLastOut.data,
685 messageLastOut.size);
686 decryptOut->size += messageLastOut.size;
687
688 HKS_FREE(messageLast.data);
689 HKS_FREE(messageLastOut.data);
690 } else {
691 HksBlob out = { .size = decrytoinLen, .data = (uint8_t *)HksMalloc(decrytoinLen) };
692 ASSERT_EQ(out.data == nullptr, false) << "out malloc failed.";
693
694 EXPECT_EQ(HksCryptoHalDecryptUpdate(decryptMsg, decryptCtx, &out,
695 usageSpec.algType), HKS_SUCCESS);
696 (void)memcpy_s((decryptOut->data), out.size, out.data, out.size);
697 decryptOut->size = out.size;
698
699 HksBlob deMessageLast = { .size = 0, .data = nullptr };
700 HksBlob messageLastOut = { .size = 0, .data = nullptr };
701 EXPECT_EQ(HksCryptoHalDecryptFinal(&deMessageLast, &decryptCtx, &messageLastOut, tagAead,
702 usageSpec.algType), HKS_SUCCESS);
703
704 HKS_FREE(deMessageLast.data);
705 HKS_FREE(out.data);
706 }
707 }
708
RunTestCaseThreeStageGCM(const TestCaseParams & testCaseParams)709 void RunTestCaseThreeStageGCM(const TestCaseParams &testCaseParams)
710 {
711 HksBlob key = { .size = 0, .data = nullptr };
712
713 uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
714 uint32_t outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT;
715
716 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
717 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
718 for (uint32_t ii = 0; ii < inLen; ii++) {
719 message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
720 }
721 HksBlob tagAead = { .size = AEAD_SIZE, .data = (uint8_t *)HksMalloc(AEAD_SIZE) };
722 HksBlob encryptAll = { .size = 0, .data = (uint8_t *)HksMalloc(outLen) };
723 HksBlob decryptAll = { .size = 0, .data = (uint8_t *)HksMalloc(outLen) };
724 ASSERT_EQ(tagAead.data == nullptr, false) << "tagAead malloc failed.";
725 ASSERT_EQ(encryptAll.data == nullptr, false) << "encryptAll malloc failed.";
726 ASSERT_EQ(decryptAll.data == nullptr, false) << "decryptAll malloc failed.";
727
728 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
729
730 RunTestEncrypt(&key, testCaseParams, &message, &encryptAll, &tagAead);
731 if (testCaseParams.encryptResult == HKS_SUCCESS) {
732 struct HksAeadParam aeadParamForGcm;
733 aeadParamForGcm.nonce = { .size = IV_SIZE, .data = (uint8_t *)IV };
734 aeadParamForGcm.aad = { .size = 0, .data = nullptr };
735 aeadParamForGcm.tagDec = tagAead;
736 aeadParamForGcm.payloadLen = 0;
737 HksUsageSpec usageSpecForGCM = {
738 .algType = HKS_ALG_AES,
739 .mode = HKS_MODE_GCM,
740 .padding = HKS_PADDING_NONE,
741 .digest = HKS_DIGEST_NONE,
742 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
743 .algParam = &aeadParamForGcm,
744 };
745 RunTestGcmDecrypt(usageSpecForGCM, &key, &encryptAll, &tagAead, &decryptAll);
746 EXPECT_EQ(message.size, decryptAll.size) << "compare size failed.";
747 EXPECT_EQ(HksMemCmp(message.data, decryptAll.data, decryptAll.size), HKS_SUCCESS) << "compare data failed.";
748 }
749
750 HKS_FREE(encryptAll.data);
751 HKS_FREE(decryptAll.data);
752 HKS_FREE(key.data);
753 HKS_FREE(tagAead.data);
754 }
755
RunTestCase(const TestCaseParams & testCaseParams) const756 void RunTestCase(const TestCaseParams &testCaseParams) const
757 {
758 HksBlob key = { .size = 0, .data = nullptr };
759
760 uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
761 uint32_t outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT;
762
763 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
764 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
765 for (uint32_t ii = 0; ii < inLen; ii++) {
766 message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
767 }
768 HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) };
769 HksBlob plaintext = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) };
770 HksBlob tagAead = { .size = AEAD_SIZE, .data = (uint8_t *)HksMalloc(AEAD_SIZE) };
771 ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
772 ASSERT_EQ(plaintext.data == nullptr, false) << "plaintext malloc failed.";
773 ASSERT_EQ(tagAead.data == nullptr, false) << "tagAead malloc failed.";
774
775 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
776 EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead),
777 testCaseParams.encryptResult);
778 if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) {
779 if (testCaseParams.usageSpec.mode == HKS_MODE_GCM) {
780 struct HksAeadParam aeadParamForGcm;
781 aeadParamForGcm.nonce = { .size = IV_SIZE, .data = (uint8_t *)IV };
782 aeadParamForGcm.aad = { .size = 0, .data = nullptr };
783 aeadParamForGcm.tagDec = tagAead;
784 aeadParamForGcm.payloadLen = 0;
785 HksUsageSpec usageSpecForGCM = {
786 .algType = HKS_ALG_AES,
787 .mode = HKS_MODE_GCM,
788 .padding = HKS_PADDING_NONE,
789 .digest = HKS_DIGEST_NONE,
790 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
791 .algParam = &aeadParamForGcm,
792 };
793 EXPECT_EQ(
794 HksCryptoHalDecrypt(&key, &usageSpecForGCM, &cipherText, &plaintext), testCaseParams.decryptResult);
795 } else {
796 EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &plaintext),
797 testCaseParams.decryptResult);
798 }
799 EXPECT_EQ(message.size, plaintext.size);
800 EXPECT_EQ(HksMemCmp(message.data, plaintext.data, plaintext.size), HKS_SUCCESS);
801 }
802
803 HKS_FREE(key.data);
804 HKS_FREE(cipherText.data);
805 HKS_FREE(plaintext.data);
806 HKS_FREE(tagAead.data);
807 }
808 };
809
SetUpTestCase(void)810 void HksCryptoHalAesCipher::SetUpTestCase(void)
811 {
812 }
813
TearDownTestCase(void)814 void HksCryptoHalAesCipher::TearDownTestCase(void)
815 {
816 }
817
SetUp()818 void HksCryptoHalAesCipher::SetUp()
819 {
820 EXPECT_EQ(HksCryptoAbilityInit(), 0);
821 }
822
TearDown()823 void HksCryptoHalAesCipher::TearDown()
824 {
825 }
826
827 /**
828 * @tc.number : HksCryptoHalAesCipher_001
829 * @tc.name :
830 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-NOPADDING key
831 */
832 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest | Level0)
833 {
834 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS);
835 }
836
837 /**
838 * @tc.number : HksCryptoHalAesCipher_002
839 * @tc.name :
840 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-PKCS7PADDING key.
841 */
842 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest | Level0)
843 {
844 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS);
845 }
846
847 /**
848 * @tc.number : HksCryptoHalAesCipher_003
849 * @tc.name :
850 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CTR-NOPADDING key.
851 */
852 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest | Level0)
853 {
854 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS);
855 }
856
857 #ifdef HKS_UNTRUSTED_RUNNING_ENV
858 /**
859 * @tc.number : HksCryptoHalAesCipher_004
860 * @tc.name :
861 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-NOPADDING key.
862 */
863 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest | Level0)
864 {
865 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS);
866 }
867
868 /**
869 * @tc.number : HksCryptoHalAesCipher_005
870 * @tc.name :
871 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-PKCS7PADDING key.
872 */
873 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest | Level0)
874 {
875 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS);
876 }
877
878 /**
879 * @tc.number : HksCryptoHalAesCipher_016
880 * @tc.name :
881 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-NOPADDING key.
882 */
883 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest | Level0)
884 {
885 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS);
886 }
887
888 /**
889 * @tc.number : HksCryptoHalAesCipher_017
890 * @tc.name :
891 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-PKCS7PADDING key.
892 */
893 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest | Level0)
894 {
895 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS);
896 }
897
898 /**
899 * @tc.number : HksCryptoHalAesCipher_010
900 * @tc.name :
901 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-NOPADDING key.
902 */
903 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest | Level0)
904 {
905 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS);
906 }
907
908 /**
909 * @tc.number : HksCryptoHalAesCipher_011
910 * @tc.name :
911 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-PKCS7PADDING key.
912 */
913 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest | Level0)
914 {
915 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS);
916 }
917 #endif
918
919
920 /**
921 * @tc.number : HksCryptoHalAesCipher_006
922 * @tc.name :
923 * @tc.desc : Generate key and Encrypt / Decrypt AES-128-GCM-NOPADDING key.
924 */
925 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest | Level0)
926 {
927 RunTestCaseThreeStageGCM(HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS);
928 }
929
930 /**
931 * @tc.number : HksCryptoHalAesCipher_007
932 * @tc.name :
933 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-NOPADDING key.
934 */
935 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest | Level0)
936 {
937 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS);
938 }
939
940 /**
941 * @tc.number : HksCryptoHalAesCipher_008
942 * @tc.name :
943 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-PKCS7PADDING key.
944 */
945 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest | Level0)
946 {
947 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS);
948 }
949
950 /**
951 * @tc.number : HksCryptoHalAesCipher_009
952 * @tc.name :
953 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CTR-NOPADDING key.
954 */
955 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest | Level0)
956 {
957 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS);
958 }
959
960
961 /**
962 * @tc.number : HksCryptoHalAesCipher_012
963 * @tc.name :
964 * @tc.desc : Generate key and Encrypt / Decrypt AES-192-GCM-NOPADDING key.
965 */
966 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest | Level0)
967 {
968 RunTestCaseThreeStageGCM(HKS_CRYPTO_HAL_AES_CIPHER_012_PARAMS);
969 }
970
971 /**
972 * @tc.number : HksCryptoHalAesCipher_013
973 * @tc.name :
974 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-NOPADDING key.
975 */
976 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest | Level0)
977 {
978 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS);
979 }
980
981 /**
982 * @tc.number : HksCryptoHalAesCipher_014
983 * @tc.name :
984 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-PKCS7PADDING key.
985 */
986 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest | Level0)
987 {
988 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS);
989 }
990
991 /**
992 * @tc.number : HksCryptoHalAesCipher_015
993 * @tc.name :
994 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CTR-NOPADDING key.
995 */
996 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest | Level0)
997 {
998 RunTestCaseThreeStage(HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS);
999 }
1000
1001
1002 /**
1003 * @tc.number : HksCryptoHalAesCipher_018
1004 * @tc.name :
1005 * @tc.desc : Generate key and Encrypt / Decrypt AES-256-GCM-NOPADDING key.
1006 */
1007 HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest | Level0)
1008 {
1009 RunTestCaseThreeStageGCM(HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS);
1010 }
1011 } // namespace UnitTest
1012 } // namespace Huks
1013 } // namespace Security
1014 } // namespace OHOS
1015