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