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