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 #include "file_ex.h"
25 #include "hks_params_key_data_01.h"
26 
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace Security {
30 namespace Huks {
31 namespace UnitTest {
32 namespace {
33 struct TestCaseParams {
34     HksUsageSpec usageSpec = {0};
35     std::string hexData;
36     std::string keyData;
37     HksKeySize keySize = HksKeySize::HKS_RSA_KEY_SIZE_512;
38 
39     HksErrorCode encryptResult = HksErrorCode::HKS_SUCCESS;
40 };
41 
42 #ifdef HKS_UNTRUSTED_RUNNING_ENV
43 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS = {
44     .usageSpec = {
45         .algType = HKS_ALG_RSA,
46         .mode = HKS_MODE_ECB,
47         .padding = HKS_PADDING_NONE,
48         .digest = HKS_DIGEST_NONE,
49         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
50         .algParam = nullptr,
51     },
52     .keyData = HKS_CRYPTO_HAL_RSA_001_PARAMS_KEY_DATA
53     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000"
54         "0000000000000000000000000000000000000",
55     .keySize = HKS_RSA_KEY_SIZE_512,
56 #if defined(_USE_OPENSSL_)
57     .encryptResult = HKS_SUCCESS,
58 #endif
59 #if defined(_USE_MBEDTLS_)
60     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
61 #endif
62 };
63 
64 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS = {
65     .usageSpec = {
66         .algType = HKS_ALG_RSA,
67         .mode = HKS_MODE_ECB,
68         .padding = HKS_PADDING_NONE,
69         .digest = HKS_DIGEST_NONE,
70         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
71         .algParam = nullptr,
72     },
73     .keyData =
74         "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5"
75         "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10"
76         "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
77         "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593"
78         "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330"
79         "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201",
80     .hexData =
81         "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
82         "0000000000000000000000000000000000000000000000000000000000000000000000000000000000",
83     .keySize = HKS_RSA_KEY_SIZE_768,
84 #if defined(_USE_OPENSSL_)
85     .encryptResult = HKS_SUCCESS,
86 #endif
87 #if defined(_USE_MBEDTLS_)
88     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
89 #endif
90 };
91 
92 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS = {
93     .usageSpec = {
94         .algType = HKS_ALG_RSA,
95         .mode = HKS_MODE_ECB,
96         .padding = HKS_PADDING_NONE,
97         .digest = HKS_DIGEST_NONE,
98         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
99         .algParam = nullptr,
100     },
101     .keyData = HKS_CRYPTO_HAL_RSA_003_PARAMS_KEY_DATA
102     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000"
103         "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
104         "00000000000000000000000000000000000000000000000000000000000000000000000000",
105     .keySize = HKS_RSA_KEY_SIZE_1024,
106 #if defined(_USE_OPENSSL_)
107     .encryptResult = HKS_SUCCESS,
108 #endif
109 #if defined(_USE_MBEDTLS_)
110     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
111 #endif
112 };
113 #endif
114 
115 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS = {
116     .usageSpec = {
117         .algType = HKS_ALG_RSA,
118         .mode = HKS_MODE_ECB,
119         .padding = HKS_PADDING_NONE,
120         .digest = HKS_DIGEST_NONE,
121         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
122         .algParam = nullptr,
123     },
124     .keyData = HKS_CRYPTO_HAL_RSA_004_PARAMS_KEY_DATA
125     .hexData =
126         "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
127         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
128         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
129         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
130         "000000000000000000000000000000000000000000000000000000000000000000000000",
131     .keySize = HKS_RSA_KEY_SIZE_2048,
132 
133 #if defined(_USE_OPENSSL_)
134     .encryptResult = HKS_SUCCESS,
135 #endif
136 #if defined(_USE_MBEDTLS_)
137     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
138 #endif
139 };
140 
141 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS = {
142     .usageSpec = {
143         .algType = HKS_ALG_RSA,
144         .mode = HKS_MODE_ECB,
145         .padding = HKS_PADDING_NONE,
146         .digest = HKS_DIGEST_NONE,
147         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
148         .algParam = nullptr,
149     },
150     .keyData = HKS_CRYPTO_HAL_RSA_005_PARAMS_KEY_DATA
151     .hexData =
152         "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
153         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
154         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
155         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
156         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
157         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
158         "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
159     .keySize = HKS_RSA_KEY_SIZE_3072,
160 
161 #if defined(_USE_OPENSSL_)
162     .encryptResult = HKS_SUCCESS,
163 #endif
164 #if defined(_USE_MBEDTLS_)
165     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
166 #endif
167 };
168 
169 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS = {
170     .usageSpec = {
171         .algType = HKS_ALG_RSA,
172         .mode = HKS_MODE_ECB,
173         .padding = HKS_PADDING_NONE,
174         .digest = HKS_DIGEST_NONE,
175         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
176         .algParam = nullptr,
177     },
178     .keyData = HKS_CRYPTO_HAL_RSA_006_PARAMS_KEY_DATA
179     .hexData =
180         "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000"
181         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
182         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
183         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
184         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
185         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
186         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
187         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
188         "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
189         "0000000000000000000000000000000000",
190     .keySize = HKS_RSA_KEY_SIZE_4096,
191 
192 #if defined(_USE_OPENSSL_)
193     .encryptResult = HKS_SUCCESS,
194 #endif
195 #if defined(_USE_MBEDTLS_)
196     .encryptResult = HKS_ERROR_NOT_SUPPORTED,
197 #endif
198 };
199 
200 #ifdef HKS_UNTRUSTED_RUNNING_ENV
201 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS = {
202     .usageSpec = {
203         .algType = HKS_ALG_RSA,
204         .mode = HKS_MODE_ECB,
205         .padding = HKS_PADDING_PKCS1_V1_5,
206         .digest = HKS_DIGEST_NONE,
207         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
208         .algParam = nullptr,
209     },
210     .keyData = HKS_CRYPTO_HAL_RSA_007_PARAMS_KEY_DATA
211     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
212     .keySize = HKS_RSA_KEY_SIZE_512,
213 
214     .encryptResult = HKS_SUCCESS,
215 };
216 
217 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS = {
218     .usageSpec = {
219         .algType = HKS_ALG_RSA,
220         .mode = HKS_MODE_ECB,
221         .padding = HKS_PADDING_PKCS1_V1_5,
222         .digest = HKS_DIGEST_NONE,
223         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
224         .algParam = nullptr,
225     },
226     .keyData = HKS_CRYPTO_HAL_RSA_008_PARAMS_KEY_DATA
227     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
228     .keySize = HKS_RSA_KEY_SIZE_768,
229 
230     .encryptResult = HKS_SUCCESS,
231 };
232 
233 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS = {
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     .keyData = HKS_CRYPTO_HAL_RSA_009_PARAMS_KEY_DATA
243     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
244     .keySize = HKS_RSA_KEY_SIZE_1024,
245 
246     .encryptResult = HKS_SUCCESS,
247 };
248 #endif
249 
250 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS = {
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     .keyData = HKS_CRYPTO_HAL_RSA_0010_PARAMS_KEY_DATA
260     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
261     .keySize = HKS_RSA_KEY_SIZE_2048,
262 
263     .encryptResult = HKS_SUCCESS,
264 };
265 
266 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS = {
267     .usageSpec = {
268         .algType = HKS_ALG_RSA,
269         .mode = HKS_MODE_ECB,
270         .padding = HKS_PADDING_PKCS1_V1_5,
271         .digest = HKS_DIGEST_NONE,
272         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
273         .algParam = nullptr,
274     },
275     .keyData = HKS_CRYPTO_HAL_RSA_0011_PARAMS_KEY_DATA
276     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
277     .keySize = HKS_RSA_KEY_SIZE_3072,
278 
279     .encryptResult = HKS_SUCCESS,
280 };
281 
282 const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS = {
283     .usageSpec = {
284         .algType = HKS_ALG_RSA,
285         .mode = HKS_MODE_ECB,
286         .padding = HKS_PADDING_PKCS1_V1_5,
287         .digest = HKS_DIGEST_NONE,
288         .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
289         .algParam = nullptr,
290     },
291     .keyData = HKS_CRYPTO_HAL_RSA_0012_PARAMS_KEY_DATA
292     .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
293     .keySize = HKS_RSA_KEY_SIZE_4096,
294 
295     .encryptResult = HKS_SUCCESS,
296 };
297 }  // namespace
298 
299 class HksCryptoHalRsaEncrypt : public HksCryptoHalCommon, public testing::Test {
300 public:
301     static void SetUpTestCase(void);
302     static void TearDownTestCase(void);
303     void TearDown();
304     void SetUp();
305 protected:
RunTestCase(const TestCaseParams & testCaseParams) const306     void RunTestCase(const TestCaseParams &testCaseParams) const
307     {
308         uint32_t keyLen = testCaseParams.keyData.length() / HKS_COUNT_OF_HALF;
309         HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) };
310         ASSERT_EQ(key.data == nullptr, false) << "key malloc failed.";
311         for (uint32_t ii = 0; ii < keyLen; ii++) {
312             key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[HKS_COUNT_OF_HALF * ii]);
313         }
314 
315         uint32_t inLen = testCaseParams.hexData.length() / HKS_COUNT_OF_HALF;
316         uint32_t outLen = inLen;
317         if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS1_V1_5) {
318             outLen = HKS_KEY_BYTES(testCaseParams.keySize);
319         }
320 
321         HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
322         ASSERT_EQ(message.data == nullptr, false) << "message malloc failed.";
323         for (uint32_t ii = 0; ii < inLen; ii++) {
324             message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[HKS_COUNT_OF_HALF * ii]);
325         }
326 
327         HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) };
328         ASSERT_EQ(cipherText.data == nullptr, false) << "cipherText malloc failed.";
329         HksBlob tagAead = { .size = 0, .data = nullptr };
330 
331         EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead),
332             testCaseParams.encryptResult);
333         HKS_FREE(key.data);
334         HKS_FREE(message.data);
335         HKS_FREE(cipherText.data);
336     }
337 };
338 
SetUpTestCase(void)339 void HksCryptoHalRsaEncrypt::SetUpTestCase(void)
340 {
341 }
342 
TearDownTestCase(void)343 void HksCryptoHalRsaEncrypt::TearDownTestCase(void)
344 {
345 }
346 
SetUp()347 void HksCryptoHalRsaEncrypt::SetUp()
348 {
349     EXPECT_EQ(HksCryptoAbilityInit(), 0);
350 }
351 
TearDown()352 void HksCryptoHalRsaEncrypt::TearDown()
353 {
354 }
355 
356 #ifdef HKS_UNTRUSTED_RUNNING_ENV
357 /**
358  * @tc.number    : HksCryptoHalRsaEncrypt_001
359  * @tc.name      : HksCryptoHalRsaEncrypt_001
360  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-512-NOPADDING key.
361  */
362 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTest | Level1)
363 {
364     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS);
365 }
366 
367 /**
368  * @tc.number    : HksCryptoHalRsaEncrypt_002
369  * @tc.name      : HksCryptoHalRsaEncrypt_002
370  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-768-NOPADDING key.
371  */
372 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTest | Level1)
373 {
374     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS);
375 }
376 
377 /**
378  * @tc.number    : HksCryptoHalRsaEncrypt_003
379  * @tc.name      : HksCryptoHalRsaEncrypt_003
380  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-1024-NOPADDING key.
381  */
382 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTest | Level1)
383 {
384     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS);
385 }
386 #endif
387 
388 /**
389  * @tc.number    : HksCryptoHalRsaEncrypt_004
390  * @tc.name      : HksCryptoHalRsaEncrypt_004
391  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-2048-NOPADDING key.
392  */
393 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTest | Level1)
394 {
395     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS);
396 }
397 
398 #ifndef CUT_RSA_4096_TEST
399 /**
400  * @tc.number    : HksCryptoHalRsaEncrypt_005
401  * @tc.name      : HksCryptoHalRsaEncrypt_005
402  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-3072-NOPADDING key.
403  */
404 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTest | Level1)
405 {
406     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS);
407 }
408 
409 /**
410  * @tc.number    : HksCryptoHalRsaEncrypt_006
411  * @tc.name      : HksCryptoHalRsaEncrypt_006
412  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-4096-NOPADDING key.
413  */
414 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTest | Level1)
415 {
416     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS);
417 }
418 #endif
419 
420 #ifdef HKS_UNTRUSTED_RUNNING_ENV
421 /**
422  * @tc.number    : HksCryptoHalRsaEncrypt_007
423  * @tc.name      : HksCryptoHalRsaEncrypt_007
424  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-512-PKCS1Padding key.
425  */
426 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTest | Level1)
427 {
428     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS);
429 }
430 
431 /**
432  * @tc.number    : HksCryptoHalRsaEncrypt_008
433  * @tc.name      : HksCryptoHalRsaEncrypt_008
434  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-768-PKCS1Padding key.
435  */
436 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTest | Level1)
437 {
438     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS);
439 }
440 
441 /**
442  * @tc.number    : HksCryptoHalRsaEncrypt_009
443  * @tc.name      : HksCryptoHalRsaEncrypt_009
444  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-1024-PKCS1Padding key.
445  */
446 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTest | Level1)
447 {
448     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS);
449 }
450 #endif
451 
452 /**
453  * @tc.number    : HksCryptoHalRsaEncrypt_010
454  * @tc.name      : HksCryptoHalRsaEncrypt_010
455  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-2048-PKCS1Padding key.
456  */
457 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTest | Level1)
458 {
459     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS);
460 }
461 
462 #ifndef CUT_RSA_4096_TEST
463 /**
464  * @tc.number    : HksCryptoHalRsaEncrypt_011
465  * @tc.name      : HksCryptoHalRsaEncrypt_011
466  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-3072-PKCS1Padding key.
467  */
468 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTest | Level1)
469 {
470     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS);
471 }
472 
473 /**
474  * @tc.number    : HksCryptoHalRsaEncrypt_012
475  * @tc.name      : HksCryptoHalRsaEncrypt_012
476  * @tc.desc      : Using HksCryptoHalEncrypt Encrypt RSA-4096-PKCS1Padding key.
477  */
478 HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_012, Function | SmallTest | Level1)
479 {
480     RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS);
481 }
482 #endif
483 }  // namespace UnitTest
484 }  // namespace Huks
485 }  // namespace Security
486 }  // namespace OHOS