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