1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <iostream>
18
19 #include "hks_ability.h"
20 #include "hks_config.h"
21 #include "hks_crypto_hal.h"
22 #include "hks_crypto_hal_common.h"
23 #include "hks_mem.h"
24
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace Security {
28 namespace Huks {
29 namespace UnitTest {
30 namespace {
31 struct TestCaseParams {
32 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 TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS = {
42 .spec = {
43 .algType = HKS_ALG_RSA,
44 .keyLen = HKS_RSA_KEY_SIZE_512,
45 .algParam = nullptr,
46 },
47 .usageSpec = {
48 .algType = HKS_ALG_RSA,
49 .mode = HKS_MODE_ECB,
50 .padding = HKS_PADDING_NONE,
51 .digest = HKS_DIGEST_NONE,
52 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
53 .algParam = nullptr,
54 },
55 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000"
56 "0000000000000000000000000000000000000",
57
58 .generateKeyResult = HKS_SUCCESS,
59 #if defined(_USE_OPENSSL_)
60 .encryptResult = HKS_SUCCESS,
61 .decryptResult = HKS_SUCCESS,
62 #endif
63 #if defined(_USE_MBEDTLS_)
64 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
65 #endif
66 };
67
68 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS = {
69 .spec = {
70 .algType = HKS_ALG_RSA,
71 .keyLen = HKS_RSA_KEY_SIZE_768,
72 .algParam = nullptr,
73 },
74 .usageSpec = {
75 .algType = HKS_ALG_RSA,
76 .mode = HKS_MODE_ECB,
77 .padding = HKS_PADDING_NONE,
78 .digest = HKS_DIGEST_NONE,
79 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
80 .algParam = nullptr,
81 },
82 .hexData =
83 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
84 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
85
86 .generateKeyResult = HKS_SUCCESS,
87 #if defined(_USE_OPENSSL_)
88 .encryptResult = HKS_SUCCESS,
89 .decryptResult = HKS_SUCCESS,
90 #endif
91 #if defined(_USE_MBEDTLS_)
92 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
93 #endif
94 };
95
96 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS = {
97 .spec = {
98 .algType = HKS_ALG_RSA,
99 .keyLen = HKS_RSA_KEY_SIZE_1024,
100 .algParam = nullptr,
101 },
102 .usageSpec = {
103 .algType = HKS_ALG_RSA,
104 .mode = HKS_MODE_ECB,
105 .padding = HKS_PADDING_NONE,
106 .digest = HKS_DIGEST_NONE,
107 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
108 .algParam = nullptr,
109 },
110 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000"
111 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
112 "00000000000000000000000000000000000000000000000000000000000000000000000000",
113
114 .generateKeyResult = HKS_SUCCESS,
115 #if defined(_USE_OPENSSL_)
116 .encryptResult = HKS_SUCCESS,
117 .decryptResult = HKS_SUCCESS,
118 #endif
119 #if defined(_USE_MBEDTLS_)
120 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
121 #endif
122 };
123
124 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS = {
125 .spec = {
126 .algType = HKS_ALG_RSA,
127 .keyLen = HKS_RSA_KEY_SIZE_2048,
128 .algParam = nullptr,
129 },
130 .usageSpec = {
131 .algType = HKS_ALG_RSA,
132 .mode = HKS_MODE_ECB,
133 .padding = HKS_PADDING_NONE,
134 .digest = HKS_DIGEST_NONE,
135 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
136 .algParam = nullptr,
137 },
138 .hexData =
139 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
140 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
141 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
142 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
143 "000000000000000000000000000000000000000000000000000000000000000000000000",
144
145 .generateKeyResult = HKS_SUCCESS,
146 #if defined(_USE_OPENSSL_)
147 .encryptResult = HKS_SUCCESS,
148 .decryptResult = HKS_SUCCESS,
149 #endif
150 #if defined(_USE_MBEDTLS_)
151 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
152 #endif
153 };
154
155 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS = {
156 .spec = {
157 .algType = HKS_ALG_RSA,
158 .keyLen = HKS_RSA_KEY_SIZE_3072,
159 .algParam = nullptr,
160 },
161 .usageSpec = {
162 .algType = HKS_ALG_RSA,
163 .mode = HKS_MODE_ECB,
164 .padding = HKS_PADDING_NONE,
165 .digest = HKS_DIGEST_NONE,
166 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
167 .algParam = nullptr,
168 },
169 .hexData =
170 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
171 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
172 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
173 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
174 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
175 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
176 "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
177
178 .generateKeyResult = HKS_SUCCESS,
179 #if defined(_USE_OPENSSL_)
180 .encryptResult = HKS_SUCCESS,
181 .decryptResult = HKS_SUCCESS,
182 #endif
183 #if defined(_USE_MBEDTLS_)
184 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
185 #endif
186 };
187
188 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS = {
189 .spec = {
190 .algType = HKS_ALG_RSA,
191 .keyLen = HKS_RSA_KEY_SIZE_4096,
192 .algParam = nullptr,
193 },
194 .usageSpec = {
195 .algType = HKS_ALG_RSA,
196 .mode = HKS_MODE_ECB,
197 .padding = HKS_PADDING_NONE,
198 .digest = HKS_DIGEST_NONE,
199 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
200 .algParam = nullptr,
201 },
202 .hexData =
203 "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
204 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
205 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
206 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
207 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
208 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
209 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
210 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
211 "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
212 "0000000000000000000000000000000000",
213
214 .generateKeyResult = HKS_SUCCESS,
215 #if defined(_USE_OPENSSL_)
216 .encryptResult = HKS_SUCCESS,
217 .decryptResult = HKS_SUCCESS,
218 #endif
219 #if defined(_USE_MBEDTLS_)
220 .encryptResult = HKS_ERROR_NOT_SUPPORTED,
221 #endif
222 };
223
224 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS = {
225 .spec = {
226 .algType = HKS_ALG_RSA,
227 .keyLen = HKS_RSA_KEY_SIZE_512,
228 .algParam = nullptr,
229 },
230 .usageSpec = {
231 .algType = HKS_ALG_RSA,
232 .mode = HKS_MODE_ECB,
233 .padding = HKS_PADDING_PKCS1_V1_5,
234 .digest = HKS_DIGEST_NONE,
235 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
236 .algParam = nullptr,
237 },
238 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
239
240 .generateKeyResult = HKS_SUCCESS,
241 .encryptResult = HKS_SUCCESS,
242 .decryptResult = HKS_SUCCESS,
243 };
244
245 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS = {
246 .spec = {
247 .algType = HKS_ALG_RSA,
248 .keyLen = HKS_RSA_KEY_SIZE_768,
249 .algParam = nullptr,
250 },
251 .usageSpec = {
252 .algType = HKS_ALG_RSA,
253 .mode = HKS_MODE_ECB,
254 .padding = HKS_PADDING_PKCS1_V1_5,
255 .digest = HKS_DIGEST_NONE,
256 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
257 .algParam = nullptr,
258 },
259 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
260
261 .generateKeyResult = HKS_SUCCESS,
262 .encryptResult = HKS_SUCCESS,
263 .decryptResult = HKS_SUCCESS,
264 };
265
266 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS = {
267 .spec = {
268 .algType = HKS_ALG_RSA,
269 .keyLen = HKS_RSA_KEY_SIZE_1024,
270 .algParam = nullptr,
271 },
272 .usageSpec = {
273 .algType = HKS_ALG_RSA,
274 .mode = HKS_MODE_ECB,
275 .padding = HKS_PADDING_PKCS1_V1_5,
276 .digest = HKS_DIGEST_NONE,
277 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
278 .algParam = nullptr,
279 },
280 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
281
282 .generateKeyResult = HKS_SUCCESS,
283 .encryptResult = HKS_SUCCESS,
284 .decryptResult = HKS_SUCCESS,
285 };
286
287 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS = {
288 .spec = {
289 .algType = HKS_ALG_RSA,
290 .keyLen = HKS_RSA_KEY_SIZE_2048,
291 .algParam = nullptr,
292 },
293 .usageSpec = {
294 .algType = HKS_ALG_RSA,
295 .mode = HKS_MODE_ECB,
296 .padding = HKS_PADDING_PKCS1_V1_5,
297 .digest = HKS_DIGEST_NONE,
298 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
299 .algParam = nullptr,
300 },
301 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
302
303 .generateKeyResult = HKS_SUCCESS,
304 .encryptResult = HKS_SUCCESS,
305 .decryptResult = HKS_SUCCESS,
306 };
307
308 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS = {
309 .spec = {
310 .algType = HKS_ALG_RSA,
311 .keyLen = HKS_RSA_KEY_SIZE_3072,
312 .algParam = nullptr,
313 },
314 .usageSpec = {
315 .algType = HKS_ALG_RSA,
316 .mode = HKS_MODE_ECB,
317 .padding = HKS_PADDING_PKCS1_V1_5,
318 .digest = HKS_DIGEST_NONE,
319 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
320 .algParam = nullptr,
321 },
322 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
323
324 .generateKeyResult = HKS_SUCCESS,
325 .encryptResult = HKS_SUCCESS,
326 .decryptResult = HKS_SUCCESS,
327 };
328
329 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS = {
330 .spec = {
331 .algType = HKS_ALG_RSA,
332 .keyLen = HKS_RSA_KEY_SIZE_4096,
333 .algParam = nullptr,
334 },
335 .usageSpec = {
336 .algType = HKS_ALG_RSA,
337 .mode = HKS_MODE_ECB,
338 .padding = HKS_PADDING_PKCS1_V1_5,
339 .digest = HKS_DIGEST_NONE,
340 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
341 .algParam = nullptr,
342 },
343 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
344
345 .generateKeyResult = HKS_SUCCESS,
346 .encryptResult = HKS_SUCCESS,
347 .decryptResult = HKS_SUCCESS,
348 };
349
350 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS = {
351 .spec = {
352 .algType = HKS_ALG_RSA,
353 .keyLen = HKS_RSA_KEY_SIZE_512,
354 .algParam = nullptr,
355 },
356 .usageSpec = {
357 .algType = HKS_ALG_RSA,
358 .mode = HKS_MODE_ECB,
359 .padding = HKS_PADDING_OAEP,
360 .digest = HKS_DIGEST_SHA1,
361 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
362 .algParam = nullptr,
363 },
364 .hexData = "00112233445566778899aabbccdd",
365
366 .generateKeyResult = HKS_SUCCESS,
367 .encryptResult = HKS_SUCCESS,
368 .decryptResult = HKS_SUCCESS,
369 };
370
371 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS = {
372 .spec = {
373 .algType = HKS_ALG_RSA,
374 .keyLen = HKS_RSA_KEY_SIZE_768,
375 .algParam = nullptr,
376 },
377 .usageSpec = {
378 .algType = HKS_ALG_RSA,
379 .mode = HKS_MODE_ECB,
380 .padding = HKS_PADDING_OAEP,
381 .digest = HKS_DIGEST_SHA1,
382 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
383 .algParam = nullptr,
384 },
385 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
386
387 .generateKeyResult = HKS_SUCCESS,
388 .encryptResult = HKS_SUCCESS,
389 .decryptResult = HKS_SUCCESS,
390 };
391
392 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS = {
393 .spec = {
394 .algType = HKS_ALG_RSA,
395 .keyLen = HKS_RSA_KEY_SIZE_1024,
396 .algParam = nullptr,
397 },
398 .usageSpec = {
399 .algType = HKS_ALG_RSA,
400 .mode = HKS_MODE_ECB,
401 .padding = HKS_PADDING_OAEP,
402 .digest = HKS_DIGEST_SHA1,
403 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
404 .algParam = nullptr,
405 },
406 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
407
408 .generateKeyResult = HKS_SUCCESS,
409 .encryptResult = HKS_SUCCESS,
410 .decryptResult = HKS_SUCCESS,
411 };
412
413 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS = {
414 .spec = {
415 .algType = HKS_ALG_RSA,
416 .keyLen = HKS_RSA_KEY_SIZE_2048,
417 .algParam = nullptr,
418 },
419 .usageSpec = {
420 .algType = HKS_ALG_RSA,
421 .mode = HKS_MODE_ECB,
422 .padding = HKS_PADDING_OAEP,
423 .digest = HKS_DIGEST_SHA1,
424 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
425 .algParam = nullptr,
426 },
427 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
428
429 .generateKeyResult = HKS_SUCCESS,
430 .encryptResult = HKS_SUCCESS,
431 .decryptResult = HKS_SUCCESS,
432 };
433
434 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS = {
435 .spec = {
436 .algType = HKS_ALG_RSA,
437 .keyLen = HKS_RSA_KEY_SIZE_3072,
438 .algParam = nullptr,
439 },
440 .usageSpec = {
441 .algType = HKS_ALG_RSA,
442 .mode = HKS_MODE_ECB,
443 .padding = HKS_PADDING_OAEP,
444 .digest = HKS_DIGEST_SHA1,
445 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
446 .algParam = nullptr,
447 },
448 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
449
450 .generateKeyResult = HKS_SUCCESS,
451 .encryptResult = HKS_SUCCESS,
452 .decryptResult = HKS_SUCCESS,
453 };
454
455 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS = {
456 .spec = {
457 .algType = HKS_ALG_RSA,
458 .keyLen = HKS_RSA_KEY_SIZE_4096,
459 .algParam = nullptr,
460 },
461 .usageSpec = {
462 .algType = HKS_ALG_RSA,
463 .mode = HKS_MODE_ECB,
464 .padding = HKS_PADDING_OAEP,
465 .digest = HKS_DIGEST_SHA1,
466 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
467 .algParam = nullptr,
468 },
469 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
470
471 .generateKeyResult = HKS_SUCCESS,
472 .encryptResult = HKS_SUCCESS,
473 .decryptResult = HKS_SUCCESS,
474 };
475
476 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS = {
477 .spec = {
478 .algType = HKS_ALG_RSA,
479 .keyLen = HKS_RSA_KEY_SIZE_512,
480 .algParam = nullptr,
481 },
482 .usageSpec = {
483 .algType = HKS_ALG_RSA,
484 .mode = HKS_MODE_ECB,
485 .padding = HKS_PADDING_OAEP,
486 .digest = HKS_DIGEST_SHA224,
487 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
488 .algParam = nullptr,
489 },
490 .hexData = "001122334455",
491
492 .generateKeyResult = HKS_SUCCESS,
493 .encryptResult = HKS_SUCCESS,
494 .decryptResult = HKS_SUCCESS,
495 };
496
497 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS = {
498 .spec = {
499 .algType = HKS_ALG_RSA,
500 .keyLen = HKS_RSA_KEY_SIZE_768,
501 .algParam = nullptr,
502 },
503 .usageSpec = {
504 .algType = HKS_ALG_RSA,
505 .mode = HKS_MODE_ECB,
506 .padding = HKS_PADDING_OAEP,
507 .digest = HKS_DIGEST_SHA224,
508 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
509 .algParam = nullptr,
510 },
511 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
512
513 .generateKeyResult = HKS_SUCCESS,
514 .encryptResult = HKS_SUCCESS,
515 .decryptResult = HKS_SUCCESS,
516 };
517
518 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS = {
519 .spec = {
520 .algType = HKS_ALG_RSA,
521 .keyLen = HKS_RSA_KEY_SIZE_1024,
522 .algParam = nullptr,
523 },
524 .usageSpec = {
525 .algType = HKS_ALG_RSA,
526 .mode = HKS_MODE_ECB,
527 .padding = HKS_PADDING_OAEP,
528 .digest = HKS_DIGEST_SHA224,
529 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
530 .algParam = nullptr,
531 },
532 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
533
534 .generateKeyResult = HKS_SUCCESS,
535 .encryptResult = HKS_SUCCESS,
536 .decryptResult = HKS_SUCCESS,
537 };
538
539 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS = {
540 .spec = {
541 .algType = HKS_ALG_RSA,
542 .keyLen = HKS_RSA_KEY_SIZE_2048,
543 .algParam = nullptr,
544 },
545 .usageSpec = {
546 .algType = HKS_ALG_RSA,
547 .mode = HKS_MODE_ECB,
548 .padding = HKS_PADDING_OAEP,
549 .digest = HKS_DIGEST_SHA224,
550 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
551 .algParam = nullptr,
552 },
553 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
554
555 .generateKeyResult = HKS_SUCCESS,
556 .encryptResult = HKS_SUCCESS,
557 .decryptResult = HKS_SUCCESS,
558 };
559
560 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS = {
561 .spec = {
562 .algType = HKS_ALG_RSA,
563 .keyLen = HKS_RSA_KEY_SIZE_3072,
564 .algParam = nullptr,
565 },
566 .usageSpec = {
567 .algType = HKS_ALG_RSA,
568 .mode = HKS_MODE_ECB,
569 .padding = HKS_PADDING_OAEP,
570 .digest = HKS_DIGEST_SHA224,
571 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
572 .algParam = nullptr,
573 },
574 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
575
576 .generateKeyResult = HKS_SUCCESS,
577 .encryptResult = HKS_SUCCESS,
578 .decryptResult = HKS_SUCCESS,
579 };
580
581 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS = {
582 .spec = {
583 .algType = HKS_ALG_RSA,
584 .keyLen = HKS_RSA_KEY_SIZE_4096,
585 .algParam = nullptr,
586 },
587 .usageSpec = {
588 .algType = HKS_ALG_RSA,
589 .mode = HKS_MODE_ECB,
590 .padding = HKS_PADDING_OAEP,
591 .digest = HKS_DIGEST_SHA224,
592 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
593 .algParam = nullptr,
594 },
595 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
596
597 .generateKeyResult = HKS_SUCCESS,
598 .encryptResult = HKS_SUCCESS,
599 .decryptResult = HKS_SUCCESS,
600 };
601
602 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS = {
603 .spec = {
604 .algType = HKS_ALG_RSA,
605 .keyLen = HKS_RSA_KEY_SIZE_768,
606 .algParam = nullptr,
607 },
608 .usageSpec = {
609 .algType = HKS_ALG_RSA,
610 .mode = HKS_MODE_ECB,
611 .padding = HKS_PADDING_OAEP,
612 .digest = HKS_DIGEST_SHA256,
613 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
614 .algParam = nullptr,
615 },
616 .hexData = "001122334455",
617
618 .generateKeyResult = HKS_SUCCESS,
619 .encryptResult = HKS_SUCCESS,
620 .decryptResult = HKS_SUCCESS,
621 };
622
623 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS = {
624 .spec = {
625 .algType = HKS_ALG_RSA,
626 .keyLen = HKS_RSA_KEY_SIZE_1024,
627 .algParam = nullptr,
628 },
629 .usageSpec = {
630 .algType = HKS_ALG_RSA,
631 .mode = HKS_MODE_ECB,
632 .padding = HKS_PADDING_OAEP,
633 .digest = HKS_DIGEST_SHA256,
634 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
635 .algParam = nullptr,
636 },
637 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
638
639 .generateKeyResult = HKS_SUCCESS,
640 .encryptResult = HKS_SUCCESS,
641 .decryptResult = HKS_SUCCESS,
642 };
643
644 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS = {
645 .spec = {
646 .algType = HKS_ALG_RSA,
647 .keyLen = HKS_RSA_KEY_SIZE_2048,
648 .algParam = nullptr,
649 },
650 .usageSpec = {
651 .algType = HKS_ALG_RSA,
652 .mode = HKS_MODE_ECB,
653 .padding = HKS_PADDING_OAEP,
654 .digest = HKS_DIGEST_SHA256,
655 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
656 .algParam = nullptr,
657 },
658 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
659
660 .generateKeyResult = HKS_SUCCESS,
661 .encryptResult = HKS_SUCCESS,
662 .decryptResult = HKS_SUCCESS,
663 };
664
665 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS = {
666 .spec = {
667 .algType = HKS_ALG_RSA,
668 .keyLen = HKS_RSA_KEY_SIZE_3072,
669 .algParam = nullptr,
670 },
671 .usageSpec = {
672 .algType = HKS_ALG_RSA,
673 .mode = HKS_MODE_ECB,
674 .padding = HKS_PADDING_OAEP,
675 .digest = HKS_DIGEST_SHA256,
676 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
677 .algParam = nullptr,
678 },
679 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
680
681 .generateKeyResult = HKS_SUCCESS,
682 .encryptResult = HKS_SUCCESS,
683 .decryptResult = HKS_SUCCESS,
684 };
685
686 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS = {
687 .spec = {
688 .algType = HKS_ALG_RSA,
689 .keyLen = HKS_RSA_KEY_SIZE_4096,
690 .algParam = nullptr,
691 },
692 .usageSpec = {
693 .algType = HKS_ALG_RSA,
694 .mode = HKS_MODE_ECB,
695 .padding = HKS_PADDING_OAEP,
696 .digest = HKS_DIGEST_SHA256,
697 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
698 .algParam = nullptr,
699 },
700 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
701
702 .generateKeyResult = HKS_SUCCESS,
703 .encryptResult = HKS_SUCCESS,
704 .decryptResult = HKS_SUCCESS,
705 };
706
707 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS = {
708 .spec = {
709 .algType = HKS_ALG_RSA,
710 .keyLen = HKS_RSA_KEY_SIZE_1024,
711 .algParam = nullptr,
712 },
713 .usageSpec = {
714 .algType = HKS_ALG_RSA,
715 .mode = HKS_MODE_ECB,
716 .padding = HKS_PADDING_OAEP,
717 .digest = HKS_DIGEST_SHA384,
718 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
719 .algParam = nullptr,
720 },
721 .hexData = "001122334455",
722
723 .generateKeyResult = HKS_SUCCESS,
724 .encryptResult = HKS_SUCCESS,
725 .decryptResult = HKS_SUCCESS,
726 };
727
728 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS = {
729 .spec = {
730 .algType = HKS_ALG_RSA,
731 .keyLen = HKS_RSA_KEY_SIZE_2048,
732 .algParam = nullptr,
733 },
734 .usageSpec = {
735 .algType = HKS_ALG_RSA,
736 .mode = HKS_MODE_ECB,
737 .padding = HKS_PADDING_OAEP,
738 .digest = HKS_DIGEST_SHA384,
739 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
740 .algParam = nullptr,
741 },
742 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
743
744 .generateKeyResult = HKS_SUCCESS,
745 .encryptResult = HKS_SUCCESS,
746 .decryptResult = HKS_SUCCESS,
747 };
748
749 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS = {
750 .spec = {
751 .algType = HKS_ALG_RSA,
752 .keyLen = HKS_RSA_KEY_SIZE_3072,
753 .algParam = nullptr,
754 },
755 .usageSpec = {
756 .algType = HKS_ALG_RSA,
757 .mode = HKS_MODE_ECB,
758 .padding = HKS_PADDING_OAEP,
759 .digest = HKS_DIGEST_SHA384,
760 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
761 .algParam = nullptr,
762 },
763 .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
764
765 .generateKeyResult = HKS_SUCCESS,
766 .encryptResult = HKS_SUCCESS,
767 .decryptResult = HKS_SUCCESS,
768 };
769
770 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS = {
771 .spec = {
772 .algType = HKS_ALG_RSA,
773 .keyLen = HKS_RSA_KEY_SIZE_4096,
774 .algParam = nullptr,
775 },
776 .usageSpec = {
777 .algType = HKS_ALG_RSA,
778 .mode = HKS_MODE_ECB,
779 .padding = HKS_PADDING_OAEP,
780 .digest = HKS_DIGEST_SHA384,
781 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
782 .algParam = nullptr,
783 },
784 .hexData = "00112233445566778899aabbccdd",
785
786 .generateKeyResult = HKS_SUCCESS,
787 .encryptResult = HKS_SUCCESS,
788 .decryptResult = HKS_SUCCESS,
789 };
790
791 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS = {
792 .spec = {
793 .algType = HKS_ALG_RSA,
794 .keyLen = HKS_RSA_KEY_SIZE_2048,
795 .algParam = nullptr,
796 },
797 .usageSpec = {
798 .algType = HKS_ALG_RSA,
799 .mode = HKS_MODE_ECB,
800 .padding = HKS_PADDING_OAEP,
801 .digest = HKS_DIGEST_SHA512,
802 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
803 .algParam = nullptr,
804 },
805 .hexData = "00112233445566778899aabbccdd",
806
807 .generateKeyResult = HKS_SUCCESS,
808 .encryptResult = HKS_SUCCESS,
809 .decryptResult = HKS_SUCCESS,
810 };
811
812 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS = {
813 .spec = {
814 .algType = HKS_ALG_RSA,
815 .keyLen = HKS_RSA_KEY_SIZE_3072,
816 .algParam = nullptr,
817 },
818 .usageSpec = {
819 .algType = HKS_ALG_RSA,
820 .mode = HKS_MODE_ECB,
821 .padding = HKS_PADDING_OAEP,
822 .digest = HKS_DIGEST_SHA512,
823 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
824 .algParam = nullptr,
825 },
826 .hexData = "00112233445566778899aabbccdd",
827
828 .generateKeyResult = HKS_SUCCESS,
829 .encryptResult = HKS_SUCCESS,
830 .decryptResult = HKS_SUCCESS,
831 };
832
833 const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS = {
834 .spec = {
835 .algType = HKS_ALG_RSA,
836 .keyLen = HKS_RSA_KEY_SIZE_4096,
837 .algParam = nullptr,
838 },
839 .usageSpec = {
840 .algType = HKS_ALG_RSA,
841 .mode = HKS_MODE_ECB,
842 .padding = HKS_PADDING_OAEP,
843 .digest = HKS_DIGEST_SHA512,
844 .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
845 .algParam = nullptr,
846 },
847 .hexData = "00112233445566778899aabbccdd",
848
849 .generateKeyResult = HKS_SUCCESS,
850 .encryptResult = HKS_SUCCESS,
851 .decryptResult = HKS_SUCCESS,
852 };
853 } // namespace
854
855 class HksCryptoHalRsaCipher : public HksCryptoHalCommon, public testing::Test {
856 public:
857 static void SetUpTestCase(void);
858 static void TearDownTestCase(void);
859 void SetUp();
860 void TearDown();
861 protected:
RunTestCase(const TestCaseParams & testCaseParams) const862 void RunTestCase(const TestCaseParams &testCaseParams) const
863 {
864 HksBlob key = { .size = 0, .data = nullptr };
865
866 uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
867 uint32_t outLen = HKS_KEY_BYTES(testCaseParams.spec.keyLen);
868
869 HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) };
870 ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
871 for (uint32_t ii = 0; ii < inLen; ii++) {
872 message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
873 }
874
875 HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) };
876 ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
877
878 HksBlob tagAead = { .size = 0, .data = nullptr };
879
880 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
881 EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead),
882 testCaseParams.encryptResult);
883 if (testCaseParams.encryptResult == HKS_SUCCESS) {
884 HksBlob inscription = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) };
885 ASSERT_EQ(inscription.data == nullptr, false) << "inscription malloc failed.";
886 EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &inscription),
887 testCaseParams.decryptResult);
888 EXPECT_EQ(inscription.size, message.size);
889 EXPECT_EQ(HksMemCmp(message.data, inscription.data, inscription.size), HKS_SUCCESS);
890 HksFree(inscription.data);
891 }
892 HksFree(key.data);
893 HksFree(message.data);
894 HksFree(cipherText.data);
895 }
896 };
897
SetUpTestCase(void)898 void HksCryptoHalRsaCipher::SetUpTestCase(void)
899 {
900 }
901
TearDownTestCase(void)902 void HksCryptoHalRsaCipher::TearDownTestCase(void)
903 {
904 }
905
SetUp()906 void HksCryptoHalRsaCipher::SetUp()
907 {
908 EXPECT_EQ(HksCryptoAbilityInit(), 0);
909 }
910
TearDown()911 void HksCryptoHalRsaCipher::TearDown()
912 {
913 }
914
915 /**
916 * @tc.number : HksCryptoHalRsaCipher_001
917 * @tc.name : HksCryptoHalRsaCipher_001
918 * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-NOPADDING key.
919 */
920 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest | Level1)
921 {
922 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS);
923 }
924
925 /**
926 * @tc.number : HksCryptoHalRsaCipher_002
927 * @tc.name : HksCryptoHalRsaCipher_002
928 * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-NOPADDING key.
929 */
930 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest | Level1)
931 {
932 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS);
933 }
934
935 /**
936 * @tc.number : HksCryptoHalRsaCipher_003
937 * @tc.name : HksCryptoHalRsaCipher_003
938 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-NOPADDING key.
939 */
940 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest | Level1)
941 {
942 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS);
943 }
944
945 /**
946 * @tc.number : HksCryptoHalRsaCipher_004
947 * @tc.name : HksCryptoHalRsaCipher_004
948 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-NOPADDING key.
949 */
950 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest | Level1)
951 {
952 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS);
953 }
954
955 #ifndef CUT_RSA_4096_TEST
956 /**
957 * @tc.number : HksCryptoHalRsaCipher_005
958 * @tc.name : HksCryptoHalRsaCipher_005
959 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-NOPADDING key.
960 */
961 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest | Level1)
962 {
963 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS);
964 }
965
966 /**
967 * @tc.number : HksCryptoHalRsaCipher_006
968 * @tc.name : HksCryptoHalRsaCipher_006
969 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-NOPADDING key.
970 */
971 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest | Level1)
972 {
973 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS);
974 }
975 #endif
976
977 /**
978 * @tc.number : HksCryptoHalRsaCipher_007
979 * @tc.name : HksCryptoHalRsaCipher_007
980 * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-PKCS1Padding key.
981 */
982 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest | Level1)
983 {
984 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS);
985 }
986
987 /**
988 * @tc.number : HksCryptoHalRsaCipher_008
989 * @tc.name : HksCryptoHalRsaCipher_008
990 * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-PKCS1Padding key.
991 */
992 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest | Level1)
993 {
994 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS);
995 }
996
997 /**
998 * @tc.number : HksCryptoHalRsaCipher_009
999 * @tc.name : HksCryptoHalRsaCipher_009
1000 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-PKCS1Padding key.
1001 */
1002 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest | Level1)
1003 {
1004 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS);
1005 }
1006
1007 /**
1008 * @tc.number : HksCryptoHalRsaCipher_010
1009 * @tc.name : HksCryptoHalRsaCipher_010
1010 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-PKCS1Padding key.
1011 */
1012 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest | Level1)
1013 {
1014 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS);
1015 }
1016
1017 #ifndef CUT_RSA_4096_TEST
1018 /**
1019 * @tc.number : HksCryptoHalRsaCipher_011
1020 * @tc.name : HksCryptoHalRsaCipher_011
1021 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-PKCS1Padding key.
1022 */
1023 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest | Level1)
1024 {
1025 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS);
1026 }
1027
1028 /**
1029 * @tc.number : HksCryptoHalRsaCipher_012
1030 * @tc.name : HksCryptoHalRsaCipher_012
1031 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-PKCS1Padding key.
1032 */
1033 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest | Level1)
1034 {
1035 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS);
1036 }
1037 #endif
1038
1039 /**
1040 * @tc.number : HksCryptoHalRsaCipher_013
1041 * @tc.name : HksCryptoHalRsaCipher_013
1042 * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA1 key.
1043 */
1044 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest | Level1)
1045 {
1046 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS);
1047 }
1048
1049 /**
1050 * @tc.number : HksCryptoHalRsaCipher_014
1051 * @tc.name : HksCryptoHalRsaCipher_014
1052 * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA1 key.
1053 */
1054 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest | Level1)
1055 {
1056 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS);
1057 }
1058
1059 /**
1060 * @tc.number : HksCryptoHalRsaCipher_015
1061 * @tc.name : HksCryptoHalRsaCipher_015
1062 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA1 key.
1063 */
1064 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest | Level1)
1065 {
1066 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS);
1067 }
1068
1069 /**
1070 * @tc.number : HksCryptoHalRsaCipher_016
1071 * @tc.name : HksCryptoHalRsaCipher_016
1072 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA1 key.
1073 */
1074 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest | Level1)
1075 {
1076 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS);
1077 }
1078
1079 #ifndef CUT_RSA_4096_TEST
1080 /**
1081 * @tc.number : HksCryptoHalRsaCipher_017
1082 * @tc.name : HksCryptoHalRsaCipher_017
1083 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA1 key.
1084 */
1085 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest | Level1)
1086 {
1087 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS);
1088 }
1089
1090 /**
1091 * @tc.number : HksCryptoHalRsaCipher_018
1092 * @tc.name : HksCryptoHalRsaCipher_018
1093 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA1 key.
1094 */
1095 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest | Level1)
1096 {
1097 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS);
1098 }
1099 #endif
1100
1101 /**
1102 * @tc.number : HksCryptoHalRsaCipher_019
1103 * @tc.name : HksCryptoHalRsaCipher_019
1104 * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA224 key.
1105 */
1106 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest | Level1)
1107 {
1108 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS);
1109 }
1110
1111 /**
1112 * @tc.number : HksCryptoHalRsaCipher_020
1113 * @tc.name : HksCryptoHalRsaCipher_020
1114 * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA224 key.
1115 */
1116 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest | Level1)
1117 {
1118 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS);
1119 }
1120
1121 /**
1122 * @tc.number : HksCryptoHalRsaCipher_021
1123 * @tc.name : HksCryptoHalRsaCipher_021
1124 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA224 key.
1125 */
1126 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest | Level1)
1127 {
1128 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS);
1129 }
1130
1131 #ifndef CUT_RSA_4096_TEST
1132 /**
1133 * @tc.number : HksCryptoHalRsaCipher_022
1134 * @tc.name : HksCryptoHalRsaCipher_022
1135 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA224 key.
1136 */
1137 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest | Level1)
1138 {
1139 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS);
1140 }
1141
1142 /**
1143 * @tc.number : HksCryptoHalRsaCipher_023
1144 * @tc.name : HksCryptoHalRsaCipher_023
1145 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA224 key.
1146 */
1147 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest | Level1)
1148 {
1149 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS);
1150 }
1151
1152 /**
1153 * @tc.number : HksCryptoHalRsaCipher_024
1154 * @tc.name : HksCryptoHalRsaCipher_024
1155 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA224 key.
1156 */
1157 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest | Level1)
1158 {
1159 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS);
1160 }
1161 #endif
1162
1163 /**
1164 * @tc.number : HksCryptoHalRsaCipher_025
1165 * @tc.name : HksCryptoHalRsaCipher_025
1166 * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA256 key.
1167 */
1168 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest | Level1)
1169 {
1170 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS);
1171 }
1172
1173 /**
1174 * @tc.number : HksCryptoHalRsaCipher_026
1175 * @tc.name : HksCryptoHalRsaCipher_026
1176 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA256 key.
1177 */
1178 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest | Level1)
1179 {
1180 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS);
1181 }
1182
1183 /**
1184 * @tc.number : HksCryptoHalRsaCipher_027
1185 * @tc.name : HksCryptoHalRsaCipher_027
1186 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA256 key.
1187 */
1188 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest | Level1)
1189 {
1190 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS);
1191 }
1192
1193 #ifndef CUT_RSA_4096_TEST
1194 /**
1195 * @tc.number : HksCryptoHalRsaCipher_028
1196 * @tc.name : HksCryptoHalRsaCipher_028
1197 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA256 key.
1198 */
1199 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest | Level1)
1200 {
1201 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS);
1202 }
1203
1204 /**
1205 * @tc.number : HksCryptoHalRsaCipher_029
1206 * @tc.name : HksCryptoHalRsaCipher_029
1207 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA256 key.
1208 */
1209 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest | Level1)
1210 {
1211 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS);
1212 }
1213 #endif
1214
1215 /**
1216 * @tc.number : HksCryptoHalRsaCipher_030
1217 * @tc.name : HksCryptoHalRsaCipher_030
1218 * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA384 key.
1219 */
1220 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest | Level1)
1221 {
1222 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS);
1223 }
1224
1225 #ifndef CUT_RSA_4096_TEST
1226 /**
1227 * @tc.number : HksCryptoHalRsaCipher_031
1228 * @tc.name : HksCryptoHalRsaCipher_031
1229 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA384 key.
1230 */
1231 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest | Level1)
1232 {
1233 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS);
1234 }
1235
1236 /**
1237 * @tc.number : HksCryptoHalRsaCipher_032
1238 * @tc.name : HksCryptoHalRsaCipher_032
1239 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA384 key.
1240 */
1241 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest | Level1)
1242 {
1243 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS);
1244 }
1245
1246 /**
1247 * @tc.number : HksCryptoHalRsaCipher_033
1248 * @tc.name : HksCryptoHalRsaCipher_033
1249 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA384 key.
1250 */
1251 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest | Level1)
1252 {
1253 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS);
1254 }
1255 #endif
1256
1257 /**
1258 * @tc.number : HksCryptoHalRsaCipher_034
1259 * @tc.name : HksCryptoHalRsaCipher_034
1260 * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA512 key.
1261 */
1262 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest | Level1)
1263 {
1264 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS);
1265 }
1266
1267 #ifndef CUT_RSA_4096_TEST
1268 /**
1269 * @tc.number : HksCryptoHalRsaCipher_035
1270 * @tc.name : HksCryptoHalRsaCipher_035
1271 * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA512 key.
1272 */
1273 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest | Level1)
1274 {
1275 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS);
1276 }
1277
1278 /**
1279 * @tc.number : HksCryptoHalRsaCipher_036
1280 * @tc.name : HksCryptoHalRsaCipher_036
1281 * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA512 key.
1282 */
1283 HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest | Level1)
1284 {
1285 RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS);
1286 }
1287 #endif
1288 } // namespace UnitTest
1289 } // namespace Huks
1290 } // namespace Security
1291 } // namespace OHOS