• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 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 "securec.h"
18 #include "asy_key_generator.h"
19 #include "cipher.h"
20 #include "key_pair.h"
21 #include "memory.h"
22 #include "cstring"
23 
24 using namespace std;
25 using namespace testing::ext;
26 
27 namespace {
28 class CryptoRsaCipherTest : public testing::Test {
29 public:
30     static void SetUpTestCase();
31     static void TearDownTestCase();
32     void SetUp();
33     void TearDown();
34 };
35 
SetUpTestCase()36 void CryptoRsaCipherTest::SetUpTestCase() {}
TearDownTestCase()37 void CryptoRsaCipherTest::TearDownTestCase() {}
SetUp()38 void CryptoRsaCipherTest::SetUp() {}
TearDown()39 void CryptoRsaCipherTest::TearDown() {}
40 
41 
42 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest90, TestSize.Level0)
43 {
44     HcfResult res = HCF_SUCCESS;
45     HcfCipher *cipher = NULL;
46     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
47     EXPECT_EQ(res, HCF_SUCCESS);
48     EXPECT_NE(cipher, nullptr);
49     EXPECT_NE(cipher->base.getClass(), nullptr);
50     EXPECT_NE(cipher->base.destroy, nullptr);
51     EXPECT_NE(cipher->init, nullptr);
52     EXPECT_NE(cipher->update, nullptr);
53     EXPECT_NE(cipher->doFinal, nullptr);
54     EXPECT_NE(cipher->getAlgorithm, nullptr);
55     HcfObjDestroy(cipher);
56 }
57 
58 
59 // HcfCipherCreate correct case: RSAXXX + padding
60 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest100, TestSize.Level0)
61 {
62     HcfResult res = HCF_SUCCESS;
63     HcfCipher *cipher = NULL;
64     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
65     EXPECT_EQ(res, HCF_SUCCESS);
66     EXPECT_NE(cipher, nullptr);
67     EXPECT_NE(cipher->base.getClass(), nullptr);
68     EXPECT_NE(cipher->base.destroy, nullptr);
69     EXPECT_NE(cipher->init, nullptr);
70     EXPECT_NE(cipher->update, nullptr);
71     EXPECT_NE(cipher->doFinal, nullptr);
72     HcfObjDestroy(cipher);
73 }
74 
75 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest110, TestSize.Level0)
76 {
77     HcfResult res = HCF_SUCCESS;
78     HcfCipher *cipher = NULL;
79     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
80     EXPECT_EQ(res, HCF_SUCCESS);
81     EXPECT_NE(cipher, nullptr);
82     EXPECT_NE(cipher->base.getClass(), nullptr);
83     EXPECT_NE(cipher->base.destroy, nullptr);
84     EXPECT_NE(cipher->init, nullptr);
85     EXPECT_NE(cipher->update, nullptr);
86     EXPECT_NE(cipher->doFinal, nullptr);
87     HcfObjDestroy(cipher);
88 }
89 
90 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest120, TestSize.Level0)
91 {
92     HcfResult res = HCF_SUCCESS;
93     HcfCipher *cipher = NULL;
94     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
95     EXPECT_EQ(res, HCF_SUCCESS);
96     EXPECT_NE(cipher, nullptr);
97     EXPECT_NE(cipher->base.getClass(), nullptr);
98     EXPECT_NE(cipher->base.destroy, nullptr);
99     EXPECT_NE(cipher->init, nullptr);
100     EXPECT_NE(cipher->update, nullptr);
101     EXPECT_NE(cipher->doFinal, nullptr);
102     HcfObjDestroy(cipher);
103 }
104 
105 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest130, TestSize.Level0)
106 {
107     HcfResult res = HCF_SUCCESS;
108     HcfCipher *cipher = NULL;
109     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher);
110     EXPECT_EQ(res, HCF_SUCCESS);
111     EXPECT_NE(cipher, nullptr);
112     EXPECT_NE(cipher->base.getClass(), nullptr);
113     EXPECT_NE(cipher->base.destroy, nullptr);
114     EXPECT_NE(cipher->init, nullptr);
115     EXPECT_NE(cipher->update, nullptr);
116     EXPECT_NE(cipher->doFinal, nullptr);
117     HcfObjDestroy(cipher);
118 }
119 
120 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest140, TestSize.Level0)
121 {
122     HcfResult res = HCF_SUCCESS;
123     HcfCipher *cipher = NULL;
124     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
125     EXPECT_EQ(res, HCF_SUCCESS);
126     EXPECT_NE(cipher, nullptr);
127     EXPECT_NE(cipher->base.getClass(), nullptr);
128     EXPECT_NE(cipher->base.destroy, nullptr);
129     EXPECT_NE(cipher->init, nullptr);
130     EXPECT_NE(cipher->update, nullptr);
131     EXPECT_NE(cipher->doFinal, nullptr);
132     HcfObjDestroy(cipher);
133 }
134 
135 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest150, TestSize.Level0)
136 {
137     HcfResult res = HCF_SUCCESS;
138     HcfCipher *cipher = NULL;
139     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA512|MGF1_SHA256", &cipher);
140     EXPECT_EQ(res, HCF_SUCCESS);
141     EXPECT_NE(cipher, nullptr);
142     EXPECT_NE(cipher->base.getClass(), nullptr);
143     EXPECT_NE(cipher->base.destroy, nullptr);
144     EXPECT_NE(cipher->init, nullptr);
145     EXPECT_NE(cipher->update, nullptr);
146     EXPECT_NE(cipher->doFinal, nullptr);
147     HcfObjDestroy(cipher);
148 }
149 
150 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest160, TestSize.Level0)
151 {
152     HcfResult res = HCF_SUCCESS;
153     HcfCipher *cipher = NULL;
154     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA256", &cipher);
155     EXPECT_EQ(res, HCF_SUCCESS);
156     EXPECT_NE(cipher, nullptr);
157     EXPECT_NE(cipher->base.getClass(), nullptr);
158     EXPECT_NE(cipher->base.destroy, nullptr);
159     EXPECT_NE(cipher->init, nullptr);
160     EXPECT_NE(cipher->update, nullptr);
161     EXPECT_NE(cipher->doFinal, nullptr);
162     HcfObjDestroy(cipher);
163 }
164 
165 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest170, TestSize.Level0)
166 {
167     HcfResult res = HCF_SUCCESS;
168     HcfCipher *cipher = NULL;
169     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher);
170     EXPECT_EQ(res, HCF_SUCCESS);
171     EXPECT_NE(cipher, nullptr);
172     EXPECT_NE(cipher->base.getClass(), nullptr);
173     EXPECT_NE(cipher->base.destroy, nullptr);
174     EXPECT_NE(cipher->init, nullptr);
175     EXPECT_NE(cipher->update, nullptr);
176     EXPECT_NE(cipher->doFinal, nullptr);
177     HcfObjDestroy(cipher);
178 }
179 
180 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest180, TestSize.Level0)
181 {
182     HcfResult res = HCF_SUCCESS;
183     HcfCipher *cipher = NULL;
184     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_MD5", &cipher);
185     EXPECT_EQ(res, HCF_SUCCESS);
186     EXPECT_NE(cipher, nullptr);
187     EXPECT_NE(cipher->base.getClass(), nullptr);
188     EXPECT_NE(cipher->base.destroy, nullptr);
189     EXPECT_NE(cipher->init, nullptr);
190     EXPECT_NE(cipher->update, nullptr);
191     EXPECT_NE(cipher->doFinal, nullptr);
192     HcfObjDestroy(cipher);
193 }
194 
195 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest190, TestSize.Level0)
196 {
197     HcfResult res = HCF_SUCCESS;
198     HcfCipher *cipher = NULL;
199     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA512", &cipher);
200     EXPECT_EQ(res, HCF_SUCCESS);
201     EXPECT_NE(cipher, nullptr);
202     EXPECT_NE(cipher->base.getClass(), nullptr);
203     EXPECT_NE(cipher->base.destroy, nullptr);
204     EXPECT_NE(cipher->init, nullptr);
205     EXPECT_NE(cipher->update, nullptr);
206     EXPECT_NE(cipher->doFinal, nullptr);
207     HcfObjDestroy(cipher);
208 }
209 
210 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest200, TestSize.Level0)
211 {
212     HcfResult res = HCF_SUCCESS;
213     HcfCipher *cipher = NULL;
214     res = HcfCipherCreate("RSA512|NoPadding", &cipher);
215     EXPECT_EQ(res, HCF_SUCCESS);
216     EXPECT_NE(cipher, nullptr);
217     EXPECT_NE(cipher->base.getClass(), nullptr);
218     EXPECT_NE(cipher->base.destroy, nullptr);
219     EXPECT_NE(cipher->init, nullptr);
220     EXPECT_NE(cipher->update, nullptr);
221     EXPECT_NE(cipher->doFinal, nullptr);
222     HcfObjDestroy(cipher);
223 }
224 
225 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest210, TestSize.Level0)
226 {
227     HcfResult res = HCF_SUCCESS;
228     HcfCipher *cipher = NULL;
229     res = HcfCipherCreate("RSA768|NoPadding", &cipher);
230     EXPECT_EQ(res, HCF_SUCCESS);
231     EXPECT_NE(cipher, nullptr);
232     EXPECT_NE(cipher->base.getClass(), nullptr);
233     EXPECT_NE(cipher->base.destroy, nullptr);
234     EXPECT_NE(cipher->init, nullptr);
235     EXPECT_NE(cipher->update, nullptr);
236     EXPECT_NE(cipher->doFinal, nullptr);
237     HcfObjDestroy(cipher);
238 }
239 
240 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest220, TestSize.Level0)
241 {
242     HcfResult res = HCF_SUCCESS;
243     HcfCipher *cipher = NULL;
244     res = HcfCipherCreate("RSA2048|NoPadding", &cipher);
245     EXPECT_EQ(res, HCF_SUCCESS);
246     EXPECT_NE(cipher, nullptr);
247     EXPECT_NE(cipher->base.getClass(), nullptr);
248     EXPECT_NE(cipher->base.destroy, nullptr);
249     EXPECT_NE(cipher->init, nullptr);
250     EXPECT_NE(cipher->update, nullptr);
251     EXPECT_NE(cipher->doFinal, nullptr);
252     HcfObjDestroy(cipher);
253 }
254 
255 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest230, TestSize.Level0)
256 {
257     HcfResult res = HCF_SUCCESS;
258     HcfCipher *cipher = NULL;
259     res = HcfCipherCreate("RSA512|PKCS1", &cipher);
260     EXPECT_EQ(res, HCF_SUCCESS);
261     EXPECT_NE(cipher, nullptr);
262     EXPECT_NE(cipher->base.getClass(), nullptr);
263     EXPECT_NE(cipher->base.destroy, nullptr);
264     EXPECT_NE(cipher->init, nullptr);
265     EXPECT_NE(cipher->update, nullptr);
266     EXPECT_NE(cipher->doFinal, nullptr);
267     HcfObjDestroy(cipher);
268 }
269 
270 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest240, TestSize.Level0)
271 {
272     HcfResult res = HCF_SUCCESS;
273     HcfCipher *cipher = NULL;
274     res = HcfCipherCreate("RSA768|PKCS1", &cipher);
275     EXPECT_EQ(res, HCF_SUCCESS);
276     EXPECT_NE(cipher, nullptr);
277     EXPECT_NE(cipher->base.getClass(), nullptr);
278     EXPECT_NE(cipher->base.destroy, nullptr);
279     EXPECT_NE(cipher->init, nullptr);
280     EXPECT_NE(cipher->update, nullptr);
281     EXPECT_NE(cipher->doFinal, nullptr);
282     HcfObjDestroy(cipher);
283 }
284 
285 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest250, TestSize.Level0)
286 {
287     HcfResult res = HCF_SUCCESS;
288     HcfCipher *cipher = NULL;
289     res = HcfCipherCreate("RSA2048|PKCS1", &cipher);
290     EXPECT_EQ(res, HCF_SUCCESS);
291     EXPECT_NE(cipher, nullptr);
292     EXPECT_NE(cipher->base.getClass(), nullptr);
293     EXPECT_NE(cipher->base.destroy, nullptr);
294     EXPECT_NE(cipher->init, nullptr);
295     EXPECT_NE(cipher->update, nullptr);
296     EXPECT_NE(cipher->doFinal, nullptr);
297     HcfObjDestroy(cipher);
298 }
299 
300 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest260, TestSize.Level0)
301 {
302     HcfResult res = HCF_SUCCESS;
303     HcfCipher *cipher = NULL;
304     res = HcfCipherCreate("RSA512|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
305     EXPECT_EQ(res, HCF_SUCCESS);
306     EXPECT_NE(cipher, nullptr);
307     EXPECT_NE(cipher->base.getClass(), nullptr);
308     EXPECT_NE(cipher->base.destroy, nullptr);
309     EXPECT_NE(cipher->init, nullptr);
310     EXPECT_NE(cipher->update, nullptr);
311     EXPECT_NE(cipher->doFinal, nullptr);
312     HcfObjDestroy(cipher);
313 }
314 
315 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest270, TestSize.Level0)
316 {
317     HcfResult res = HCF_SUCCESS;
318     HcfCipher *cipher = NULL;
319     res = HcfCipherCreate("RSA768|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
320     EXPECT_EQ(res, HCF_SUCCESS);
321     EXPECT_NE(cipher, nullptr);
322     EXPECT_NE(cipher->base.getClass(), nullptr);
323     EXPECT_NE(cipher->base.destroy, nullptr);
324     EXPECT_NE(cipher->init, nullptr);
325     EXPECT_NE(cipher->update, nullptr);
326     EXPECT_NE(cipher->doFinal, nullptr);
327     HcfObjDestroy(cipher);
328 }
329 
330 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest280, TestSize.Level0)
331 {
332     HcfResult res = HCF_SUCCESS;
333     HcfCipher *cipher = NULL;
334     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
335     EXPECT_EQ(res, HCF_SUCCESS);
336     EXPECT_NE(cipher, nullptr);
337     EXPECT_NE(cipher->base.getClass(), nullptr);
338     EXPECT_NE(cipher->base.destroy, nullptr);
339     EXPECT_NE(cipher->init, nullptr);
340     EXPECT_NE(cipher->update, nullptr);
341     EXPECT_NE(cipher->doFinal, nullptr);
342     HcfObjDestroy(cipher);
343 }
344 
345 // HcfCipherCreate Incorrect case
346 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest300, TestSize.Level0)
347 {
348     HcfResult res = HCF_SUCCESS;
349     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", NULL);
350     EXPECT_NE(res, HCF_SUCCESS);
351 }
352 
353 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest310, TestSize.Level0)
354 {
355     HcfResult res = HCF_SUCCESS;
356     HcfCipher *cipher = NULL;
357     res = HcfCipherCreate(NULL, &cipher);
358     EXPECT_NE(res, HCF_SUCCESS);
359     EXPECT_EQ(cipher, nullptr);
360 }
361 
362 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest320, TestSize.Level0)
363 {
364     HcfResult res = HCF_SUCCESS;
365     HcfCipher *cipher = NULL;
366     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256|2111111111111111111111111111111111111111111111"
367         "111111111111123123", &cipher);
368     EXPECT_NE(res, HCF_SUCCESS);
369     EXPECT_EQ(cipher, nullptr);
370 }
371 
372 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest330, TestSize.Level0)
373 {
374     HcfResult res = HCF_SUCCESS;
375     HcfCipher *cipher = NULL;
376     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA333", &cipher);
377     EXPECT_NE(res, HCF_SUCCESS);
378     EXPECT_EQ(cipher, nullptr);
379 }
380 
381 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest340, TestSize.Level0)
382 {
383     HcfResult res = HCF_SUCCESS;
384     HcfCipher *cipher = NULL;
385     res = HcfCipherCreate("RSA2048|PKCS1_OAEP111|SHA256|MGF1_SHA333", &cipher);
386     EXPECT_NE(res, HCF_SUCCESS);
387     EXPECT_EQ(cipher, nullptr);
388 }
389 
390 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest350, TestSize.Level0)
391 {
392     HcfResult res = HCF_SUCCESS;
393     HcfCipher *cipher = NULL;
394     res = HcfCipherCreate("RSA2111048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
395     EXPECT_NE(res, HCF_SUCCESS);
396     EXPECT_EQ(cipher, nullptr);
397 }
398 
399 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest360, TestSize.Level0)
400 {
401     HcfResult res = HCF_SUCCESS;
402     HcfCipher *cipher = NULL;
403     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256111|MGF1_SHA256", &cipher);
404     EXPECT_NE(res, HCF_SUCCESS);
405     EXPECT_EQ(cipher, nullptr);
406 }
407 
408 // Create Cipher without padding
409 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest370, TestSize.Level0)
410 {
411     HcfResult res = HCF_SUCCESS;
412     HcfCipher *cipher = NULL;
413     res = HcfCipherCreate("RSA2048", &cipher);
414     EXPECT_NE(res, HCF_SUCCESS);
415 }
416 
417 // create Nopadding Cipher with md digest.
418 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest380, TestSize.Level0)
419 {
420     HcfResult res = HCF_SUCCESS;
421     HcfCipher *cipher = NULL;
422     res = HcfCipherCreate("RSA2048|NoPadding|SHA256", &cipher);
423     EXPECT_NE(res, HCF_SUCCESS);
424 }
425 
426 
427 // destroyCipher
428 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest400, TestSize.Level0)
429 {
430     HcfResult res = HCF_SUCCESS;
431     HcfCipher *cipher = NULL;
432     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
433     EXPECT_EQ(res, HCF_SUCCESS);
434     EXPECT_NE(cipher, nullptr);
435     HcfObjDestroy(cipher);
436     cipher = NULL;
437     HcfObjDestroy(cipher);
438 }
439 
440 // init correct case
441 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest500, TestSize.Level0)
442 {
443     HcfResult res = HCF_SUCCESS;
444     HcfAsyKeyGenerator *generator = NULL;
445     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
446     EXPECT_EQ(res, HCF_SUCCESS);
447     HcfKeyPair *keyPair = NULL;
448     res = generator->generateKeyPair(generator, NULL, &keyPair);
449     EXPECT_EQ(res, HCF_SUCCESS);
450 
451     HcfCipher *cipher = NULL;
452     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
453     EXPECT_EQ(res, HCF_SUCCESS);
454     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
455     EXPECT_EQ(res, HCF_SUCCESS);
456 
457     HcfObjDestroy(keyPair);
458     HcfObjDestroy(generator);
459     HcfObjDestroy(cipher);
460 }
461 
462 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest501, TestSize.Level0)
463 {
464     HcfResult res = HCF_SUCCESS;
465     HcfAsyKeyGenerator *generator = NULL;
466     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
467     EXPECT_EQ(res, HCF_SUCCESS);
468     HcfKeyPair *keyPair = NULL;
469     res = generator->generateKeyPair(generator, NULL, &keyPair);
470     EXPECT_EQ(res, HCF_SUCCESS);
471 
472     HcfCipher *cipher = NULL;
473     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
474     EXPECT_EQ(res, HCF_SUCCESS);
475     res = cipher->init(cipher, (enum HcfCryptoMode)123, (HcfKey *)keyPair->pubKey, NULL);
476     EXPECT_NE(res, HCF_SUCCESS);
477 
478     HcfObjDestroy(keyPair);
479     HcfObjDestroy(generator);
480     HcfObjDestroy(cipher);
481 }
482 
483 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest510, TestSize.Level0)
484 {
485     HcfResult res = HCF_SUCCESS;
486     HcfAsyKeyGenerator *generator = NULL;
487     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
488     EXPECT_EQ(res, HCF_SUCCESS);
489     HcfKeyPair *keyPair = NULL;
490     res = generator->generateKeyPair(generator, NULL, &keyPair);
491     EXPECT_EQ(res, HCF_SUCCESS);
492 
493     HcfCipher *cipher = NULL;
494     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
495     EXPECT_EQ(res, HCF_SUCCESS);
496     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
497     EXPECT_EQ(res, HCF_SUCCESS);
498 
499     HcfObjDestroy(keyPair);
500     HcfObjDestroy(generator);
501     HcfObjDestroy(cipher);
502 }
503 
504 // init incorrect case
505 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest600, TestSize.Level0)
506 {
507     HcfResult res = HCF_SUCCESS;
508     HcfAsyKeyGenerator *generator = NULL;
509     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
510     EXPECT_EQ(res, HCF_SUCCESS);
511     HcfKeyPair *keyPair = NULL;
512     res = generator->generateKeyPair(generator, NULL, &keyPair);
513     EXPECT_EQ(res, HCF_SUCCESS);
514 
515     HcfCipher *cipher = NULL;
516     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
517     EXPECT_EQ(res, HCF_SUCCESS);
518     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
519     EXPECT_NE(res, HCF_SUCCESS);
520 
521     HcfObjDestroy(keyPair);
522     HcfObjDestroy(generator);
523     HcfObjDestroy(cipher);
524 }
525 
526 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest610, TestSize.Level0)
527 {
528     HcfResult res = HCF_SUCCESS;
529     HcfAsyKeyGenerator *generator = NULL;
530     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
531     EXPECT_EQ(res, HCF_SUCCESS);
532     HcfKeyPair *keyPair = NULL;
533     res = generator->generateKeyPair(generator, NULL, &keyPair);
534     EXPECT_EQ(res, HCF_SUCCESS);
535 
536     HcfCipher *cipher = NULL;
537     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
538     EXPECT_EQ(res, HCF_SUCCESS);
539     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
540     EXPECT_NE(res, HCF_SUCCESS);
541 
542     HcfObjDestroy(keyPair);
543     HcfObjDestroy(generator);
544     HcfObjDestroy(cipher);
545 }
546 
547 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest620, TestSize.Level0)
548 {
549     HcfResult res = HCF_SUCCESS;
550     HcfAsyKeyGenerator *generator = NULL;
551     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
552     EXPECT_EQ(res, HCF_SUCCESS);
553     HcfKeyPair *keyPair = NULL;
554     res = generator->generateKeyPair(generator, NULL, &keyPair);
555     EXPECT_EQ(res, HCF_SUCCESS);
556 
557     HcfCipher *cipher = NULL;
558     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
559     EXPECT_EQ(res, HCF_SUCCESS);
560     res = cipher->init(NULL, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
561     EXPECT_NE(res, HCF_SUCCESS);
562 
563     HcfObjDestroy(keyPair);
564     HcfObjDestroy(generator);
565     HcfObjDestroy(cipher);
566 }
567 
568 // incorrect case: use diff class, we ignore it in this version
569 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest630, TestSize.Level0)
570 {
571     HcfResult res = HCF_SUCCESS;
572     HcfAsyKeyGenerator *generator = NULL;
573     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
574     EXPECT_EQ(res, HCF_SUCCESS);
575     HcfKeyPair *keyPair = NULL;
576     res = generator->generateKeyPair(generator, NULL, &keyPair);
577     EXPECT_EQ(res, HCF_SUCCESS);
578 
579     HcfCipher *aesCipher = NULL;
580     res = HcfCipherCreate("AES128|ECB|PKCS7", &aesCipher);
581     EXPECT_EQ(res, HCF_SUCCESS);
582 
583     HcfCipher *cipher = NULL;
584     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
585     EXPECT_EQ(res, HCF_SUCCESS);
586     res = cipher->init(aesCipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
587     EXPECT_NE(res, HCF_SUCCESS);
588 
589     HcfObjDestroy(keyPair);
590     HcfObjDestroy(generator);
591     HcfObjDestroy(cipher);
592     HcfObjDestroy(aesCipher);
593 }
594 
595 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest640, TestSize.Level0)
596 {
597     HcfResult res = HCF_SUCCESS;
598     HcfCipher *cipher = NULL;
599     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
600     EXPECT_EQ(res, HCF_SUCCESS);
601     res = cipher->init(cipher, DECRYPT_MODE, NULL, NULL);
602     EXPECT_NE(res, HCF_SUCCESS);
603     HcfObjDestroy(cipher);
604 }
605 
606 // correct case: update not support
607 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest700, TestSize.Level0)
608 {
609     uint8_t plan[] = "this is rsa cipher test!\0";
610     HcfResult res = HCF_SUCCESS;
611     HcfAsyKeyGenerator *generator = NULL;
612     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
613     EXPECT_EQ(res, HCF_SUCCESS);
614     HcfKeyPair *keyPair = NULL;
615     res = generator->generateKeyPair(generator, NULL, &keyPair);
616     EXPECT_EQ(res, HCF_SUCCESS);
617 
618     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
619     HcfBlob encoutput = {.data = NULL, .len = 0};
620     HcfCipher *cipher = NULL;
621     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
622     EXPECT_EQ(res, HCF_SUCCESS);
623     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
624     EXPECT_EQ(res, HCF_SUCCESS);
625     res = cipher->update(cipher, &input, &encoutput);
626     EXPECT_NE(res, HCF_SUCCESS);
627     EXPECT_EQ(encoutput.data, nullptr);
628 
629     HcfObjDestroy(keyPair);
630     HcfObjDestroy(generator);
631     HcfObjDestroy(cipher);
632 }
633 
634 // dofinal correct case
635 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest800, TestSize.Level0)
636 {
637     HcfResult res = HCF_SUCCESS;
638     uint8_t plan[] = "this is rsa cipher test!\0";
639     HcfAsyKeyGenerator *generator = NULL;
640     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
641     EXPECT_EQ(res, HCF_SUCCESS);
642     HcfKeyPair *keyPair = NULL;
643     res = generator->generateKeyPair(generator, NULL, &keyPair);
644     EXPECT_EQ(res, HCF_SUCCESS);
645     EXPECT_NE(keyPair, nullptr);
646     EXPECT_NE(keyPair->priKey, nullptr);
647     EXPECT_NE(keyPair->pubKey, nullptr);
648 
649     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
650     HcfBlob encoutput = {.data = NULL, .len = 0};
651     HcfCipher *cipher = NULL;
652     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
653     EXPECT_EQ(res, HCF_SUCCESS);
654 
655     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
656     EXPECT_EQ(res, HCF_SUCCESS);
657     res = cipher->doFinal(cipher, &input, &encoutput);
658     EXPECT_EQ(res, HCF_SUCCESS);
659     HcfObjDestroy(cipher);
660 
661     HcfBlob decoutput = {.data = NULL, .len = 0};
662     cipher = NULL;
663     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
664     EXPECT_EQ(res, HCF_SUCCESS);
665     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
666     EXPECT_EQ(res, HCF_SUCCESS);
667     res = cipher->doFinal(cipher, &encoutput, &decoutput);
668     EXPECT_EQ(res, HCF_SUCCESS);
669     HcfObjDestroy(cipher);
670     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
671 
672     HcfFree(encoutput.data);
673     HcfFree(decoutput.data);
674 
675     HcfObjDestroy(keyPair);
676     HcfObjDestroy(generator);
677 }
678 
679 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest810, TestSize.Level0)
680 {
681     HcfResult res = HCF_SUCCESS;
682     uint8_t plan[] = "this is rsa cipher test!\0";
683     HcfAsyKeyGenerator *generator = NULL;
684     res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_3", &generator);
685     EXPECT_EQ(res, HCF_SUCCESS);
686     HcfKeyPair *keyPair = NULL;
687     res = generator->generateKeyPair(generator, NULL, &keyPair);
688     EXPECT_EQ(res, HCF_SUCCESS);
689     EXPECT_NE(keyPair, nullptr);
690     EXPECT_NE(keyPair->priKey, nullptr);
691     EXPECT_NE(keyPair->pubKey, nullptr);
692 
693     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
694     HcfBlob encoutput = {.data = NULL, .len = 0};
695     HcfCipher *cipher = NULL;
696     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
697     EXPECT_EQ(res, HCF_SUCCESS);
698 
699     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
700     EXPECT_EQ(res, HCF_SUCCESS);
701     res = cipher->doFinal(cipher, &input, &encoutput);
702     EXPECT_EQ(res, HCF_SUCCESS);
703     HcfObjDestroy(cipher);
704 
705     HcfBlob decoutput = {.data = NULL, .len = 0};
706     cipher = NULL;
707     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
708     EXPECT_EQ(res, HCF_SUCCESS);
709     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
710     EXPECT_EQ(res, HCF_SUCCESS);
711     res = cipher->doFinal(cipher, &encoutput, &decoutput);
712     EXPECT_EQ(res, HCF_SUCCESS);
713     HcfObjDestroy(cipher);
714     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
715 
716     HcfFree(encoutput.data);
717     HcfFree(decoutput.data);
718 
719     HcfObjDestroy(keyPair);
720     HcfObjDestroy(generator);
721 }
722 
723 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest820, TestSize.Level0)
724 {
725     HcfResult res = HCF_SUCCESS;
726     uint8_t plan[] = "this is rsa cipher test!\0";
727     HcfAsyKeyGenerator *generator = NULL;
728     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
729 
730     HcfKeyPair *keyPair = NULL;
731     res = generator->generateKeyPair(generator, NULL, &keyPair);
732     EXPECT_EQ(res, HCF_SUCCESS);
733     EXPECT_NE(keyPair, nullptr);
734     EXPECT_NE(keyPair->priKey, nullptr);
735     EXPECT_NE(keyPair->pubKey, nullptr);
736 
737     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
738     HcfBlob encoutput = {.data = NULL, .len = 0};
739     HcfCipher *cipher = NULL;
740     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
741     EXPECT_EQ(res, HCF_SUCCESS);
742 
743     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
744     EXPECT_EQ(res, HCF_SUCCESS);
745     res = cipher->doFinal(cipher, &input, &encoutput);
746     EXPECT_EQ(res, HCF_SUCCESS);
747     HcfObjDestroy(cipher);
748 
749     HcfBlob decoutput = {.data = NULL, .len = 0};
750     cipher = NULL;
751     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
752     EXPECT_EQ(res, HCF_SUCCESS);
753     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
754     EXPECT_EQ(res, HCF_SUCCESS);
755     res = cipher->doFinal(cipher, &encoutput, &decoutput);
756     EXPECT_EQ(res, HCF_SUCCESS);
757     HcfObjDestroy(cipher);
758     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
759 
760     HcfFree(encoutput.data);
761     HcfFree(decoutput.data);
762 
763     HcfObjDestroy(keyPair);
764     HcfObjDestroy(generator);
765 }
766 
767 // incorrect case: algName out of boundary
768 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest830, TestSize.Level0)
769 {
770     HcfResult res = HCF_SUCCESS;
771     uint8_t plan[] = "this is rsa cipher test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
772         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!\0";
773     HcfAsyKeyGenerator *generator = NULL;
774     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
775 
776     HcfKeyPair *keyPair = NULL;
777     res = generator->generateKeyPair(generator, NULL, &keyPair);
778     EXPECT_EQ(res, HCF_SUCCESS);
779     EXPECT_NE(keyPair, nullptr);
780     EXPECT_NE(keyPair->priKey, nullptr);
781     EXPECT_NE(keyPair->pubKey, nullptr);
782 
783     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
784     HcfBlob encoutput = {.data = NULL, .len = 0};
785     HcfCipher *cipher = NULL;
786     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
787     EXPECT_EQ(res, HCF_SUCCESS);
788 
789     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
790     EXPECT_EQ(res, HCF_SUCCESS);
791     res = cipher->doFinal(cipher, &input, &encoutput);
792     EXPECT_NE(res, HCF_SUCCESS);
793     HcfObjDestroy(cipher);
794 
795     HcfBlob decoutput = {.data = NULL, .len = 0};
796     cipher = NULL;
797     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
798     EXPECT_EQ(res, HCF_SUCCESS);
799     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
800     EXPECT_EQ(res, HCF_SUCCESS);
801     res = cipher->doFinal(cipher, &encoutput, &decoutput);
802     EXPECT_NE(res, HCF_SUCCESS);
803     HcfObjDestroy(cipher);
804     EXPECT_STRNE((char *)plan, (char *)decoutput.data);
805 
806     HcfFree(encoutput.data);
807     HcfFree(decoutput.data);
808 
809     HcfObjDestroy(keyPair);
810     HcfObjDestroy(generator);
811 }
812 
813 
814 // Incorrect case: use OAEP pading without mgf1md
815 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest840, TestSize.Level0)
816 {
817     HcfResult res = HCF_SUCCESS;
818 
819     HcfAsyKeyGenerator *generator = NULL;
820     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
821 
822     HcfKeyPair *keyPair = NULL;
823     res = generator->generateKeyPair(generator, NULL, &keyPair);
824     HcfObjDestroy(generator);
825     HcfObjDestroy(keyPair);
826 
827     HcfCipher *cipher = NULL;
828     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256", &cipher);
829     EXPECT_NE(res, HCF_SUCCESS);
830     EXPECT_EQ(cipher, nullptr);
831 }
832 
833 // Incorrect case: use OAEP pading without md
834 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest845, TestSize.Level0)
835 {
836     HcfResult res = HCF_SUCCESS;
837 
838     HcfAsyKeyGenerator *generator = NULL;
839     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
840 
841     HcfKeyPair *keyPair = NULL;
842     res = generator->generateKeyPair(generator, NULL, &keyPair);
843     HcfObjDestroy(generator);
844     HcfObjDestroy(keyPair);
845 
846     HcfCipher *cipher = NULL;
847     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|MGF1_SHA256", &cipher);
848     EXPECT_NE(res, HCF_SUCCESS);
849     EXPECT_EQ(cipher, nullptr);
850 }
851 
852 // Correct case: test genEncoded and convert key
853 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest850, TestSize.Level0)
854 {
855     uint8_t plan[] = "this is rsa cipher test!\0";
856     HcfAsyKeyGenerator *generator = NULL;
857     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
858     EXPECT_EQ(res, HCF_SUCCESS);
859     EXPECT_NE(generator, nullptr);
860 
861     HcfKeyPair *keyPair = NULL;
862     res = generator->generateKeyPair(generator, NULL, &keyPair);
863     EXPECT_EQ(res, HCF_SUCCESS);
864     HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
865     HcfBlob priKeyBlob = {.data = NULL, .len = 0};
866     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
867     EXPECT_EQ(res, HCF_SUCCESS);
868     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
869     EXPECT_EQ(res, HCF_SUCCESS);
870 
871     HcfKeyPair *dupKeyPair = NULL;
872     res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
873     EXPECT_EQ(res, HCF_SUCCESS);
874 
875     HcfObjDestroy(generator);
876     HcfObjDestroy(keyPair);
877 
878     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
879     HcfBlob encoutput = {.data = NULL, .len = 0};
880     HcfCipher *cipher = NULL;
881     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
882     EXPECT_EQ(res, HCF_SUCCESS);
883 
884     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)dupKeyPair->pubKey, NULL);
885     EXPECT_EQ(res, HCF_SUCCESS);
886     res = cipher->doFinal(cipher, &input, &encoutput);
887     EXPECT_EQ(res, HCF_SUCCESS);
888     HcfObjDestroy(cipher);
889 
890     HcfBlob decoutput = {.data = NULL, .len = 0};
891     cipher = NULL;
892     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
893     EXPECT_EQ(res, HCF_SUCCESS);
894     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)dupKeyPair->priKey, NULL);
895     EXPECT_EQ(res, HCF_SUCCESS);
896     res = cipher->doFinal(cipher, &encoutput, &decoutput);
897     EXPECT_EQ(res, HCF_SUCCESS);
898     HcfObjDestroy(cipher);
899     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
900 
901     HcfFree(encoutput.data);
902     HcfFree(decoutput.data);
903     HcfFree(pubKeyBlob.data);
904     HcfFree(priKeyBlob.data);
905     HcfObjDestroy(dupKeyPair);
906 }
907 
908 // correct case: test OAEP Plaintext boundary:
909 // RSA_size - (md_result_len * mgf1md_result_len) - 2 = 128 - (32 + 32) - 2 = 62
910 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest860, TestSize.Level0)
911 {
912     HcfResult res = HCF_SUCCESS;
913     uint8_t plan1[] = "00112233445566778899aabbccddeeff0aaaaaaaaaaaaaaaaaaaaaaaaaa";
914     uint8_t plan2[] = "00112233445566778899aabbccddeeffaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
915     uint8_t plan3[] = "00112233445566778899aabbccddeeff00112233445566778899aaaaaaaaaa";
916     HcfAsyKeyGenerator *generator = NULL;
917     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
918 
919     HcfKeyPair *keyPair = NULL;
920     res = generator->generateKeyPair(generator, NULL, &keyPair);
921     EXPECT_EQ(res, HCF_SUCCESS);
922     EXPECT_NE(keyPair, nullptr);
923     EXPECT_NE(keyPair->priKey, nullptr);
924     EXPECT_NE(keyPair->pubKey, nullptr);
925 
926     HcfCipher *cipher = NULL;
927     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
928     EXPECT_EQ(res, HCF_SUCCESS);
929 
930     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
931     EXPECT_EQ(res, HCF_SUCCESS);
932 
933     HcfBlob encoutput1 = {.data = NULL, .len = 0};
934     HcfBlob encoutput2 = {.data = NULL, .len = 0};
935     HcfBlob encoutput3 = {.data = NULL, .len = 0};
936     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
937     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
938     HcfBlob input3 = {.data = (uint8_t *)plan3, .len = strlen((char *)plan3)};
939     res = cipher->doFinal(cipher, &input1, &encoutput1);
940     EXPECT_EQ(res, HCF_SUCCESS);
941     res = cipher->doFinal(cipher, &input2, &encoutput2);
942     EXPECT_NE(res, HCF_SUCCESS);
943     res = cipher->doFinal(cipher, &input3, &encoutput2);
944     EXPECT_EQ(res, HCF_SUCCESS);
945 
946 
947     HcfObjDestroy(cipher);
948     HcfFree(encoutput1.data);
949     HcfFree(encoutput2.data);
950     HcfFree(encoutput3.data);
951     HcfObjDestroy(keyPair);
952     HcfObjDestroy(generator);
953 }
954 
955 // correct case: test nopadding boundary < RSA_size(rsa)
956 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest870, TestSize.Level0)
957 {
958     HcfResult res = HCF_SUCCESS;
959     uint8_t plan1[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
960         "1122334455111111111116";
961     uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
962         "112233445511111111111611111111111";
963 
964     HcfAsyKeyGenerator *generator = NULL;
965     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
966 
967     HcfKeyPair *keyPair = NULL;
968     res = generator->generateKeyPair(generator, NULL, &keyPair);
969     EXPECT_EQ(res, HCF_SUCCESS);
970     EXPECT_NE(keyPair, nullptr);
971     EXPECT_NE(keyPair->priKey, nullptr);
972     EXPECT_NE(keyPair->pubKey, nullptr);
973 
974     HcfCipher *cipher = NULL;
975     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
976     EXPECT_EQ(res, HCF_SUCCESS);
977 
978     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
979     EXPECT_EQ(res, HCF_SUCCESS);
980 
981 
982     HcfBlob encoutput1 = {.data = NULL, .len = 0};
983     HcfBlob encoutput2 = {.data = NULL, .len = 0};
984 
985     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
986     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
987 
988     res = cipher->doFinal(cipher, &input1, &encoutput1);
989     EXPECT_NE(res, HCF_SUCCESS);
990     res = cipher->doFinal(cipher, &input2, &encoutput2);
991     EXPECT_EQ(res, HCF_SUCCESS);
992 
993     HcfObjDestroy(cipher);
994     HcfFree(encoutput1.data);
995     HcfFree(encoutput2.data);
996     HcfObjDestroy(keyPair);
997     HcfObjDestroy(generator);
998 }
999 
1000 // correct case: test PKCS1 boundary < RSA_size(rsa) - 11
1001 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest880, TestSize.Level0)
1002 {
1003     HcfResult res = HCF_SUCCESS;
1004     uint8_t plan1[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1005         "1122334455111111111116";
1006     uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1007         "11223344551111111111161";
1008 
1009     HcfAsyKeyGenerator *generator = NULL;
1010     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1011 
1012     HcfKeyPair *keyPair = NULL;
1013     res = generator->generateKeyPair(generator, NULL, &keyPair);
1014     EXPECT_EQ(res, HCF_SUCCESS);
1015     EXPECT_NE(keyPair, nullptr);
1016     EXPECT_NE(keyPair->priKey, nullptr);
1017     EXPECT_NE(keyPair->pubKey, nullptr);
1018 
1019     HcfCipher *cipher = NULL;
1020     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1021     EXPECT_EQ(res, HCF_SUCCESS);
1022 
1023     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
1024     EXPECT_EQ(res, HCF_SUCCESS);
1025 
1026     HcfBlob encoutput1 = {.data = NULL, .len = 0};
1027     HcfBlob encoutput2 = {.data = NULL, .len = 0};
1028 
1029     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
1030     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
1031 
1032     res = cipher->doFinal(cipher, &input1, &encoutput1);
1033     EXPECT_EQ(res, HCF_SUCCESS);
1034     res = cipher->doFinal(cipher, &input2, &encoutput2);
1035     EXPECT_NE(res, HCF_SUCCESS);
1036 
1037     HcfObjDestroy(cipher);
1038     HcfFree(encoutput1.data);
1039     HcfFree(encoutput2.data);
1040     HcfObjDestroy(keyPair);
1041     HcfObjDestroy(generator);
1042 }
1043 
1044 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest890, TestSize.Level0)
1045 {
1046     HcfResult res = HCF_SUCCESS;
1047     HcfAsyKeyGenerator *generator = NULL;
1048     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1049     EXPECT_EQ(res, HCF_SUCCESS);
1050 
1051     HcfKeyPair *keyPair = NULL;
1052     res = generator->generateKeyPair(generator, NULL, &keyPair);
1053     HcfCipher *cipher = NULL;
1054     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1055     EXPECT_EQ(res, HCF_SUCCESS);
1056 
1057     res = cipher->init((HcfCipher *)generator, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
1058     EXPECT_NE(res, HCF_SUCCESS);
1059 
1060     HcfObjDestroy(generator);
1061     HcfObjDestroy(cipher);
1062     HcfObjDestroy(keyPair);
1063 }
1064 
1065 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest900, TestSize.Level0)
1066 {
1067     HcfResult res = HCF_SUCCESS;
1068     HcfAsyKeyGenerator *generator = NULL;
1069     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1070     HcfKeyPair *keyPair = NULL;
1071     res = generator->generateKeyPair(generator, NULL, &keyPair);
1072     EXPECT_EQ(res, HCF_SUCCESS);
1073     EXPECT_NE(keyPair, nullptr);
1074     EXPECT_NE(keyPair->priKey, nullptr);
1075     EXPECT_NE(keyPair->pubKey, nullptr);
1076 
1077     HcfCipher *cipher = NULL;
1078     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1079     EXPECT_EQ(res, HCF_SUCCESS);
1080 
1081     uint8_t plan[] = "12312123123";
1082     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1083 
1084     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
1085     EXPECT_EQ(res, HCF_SUCCESS);
1086 
1087     res = cipher->doFinal(cipher, &input, NULL);
1088     EXPECT_NE(res, HCF_SUCCESS);
1089 
1090     HcfObjDestroy(keyPair);
1091     HcfObjDestroy(generator);
1092     HcfObjDestroy(cipher);
1093 }
1094 
1095 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest910, TestSize.Level0)
1096 {
1097     HcfResult res = HCF_SUCCESS;
1098     HcfAsyKeyGenerator *generator = NULL;
1099     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1100     HcfKeyPair *keyPair = NULL;
1101     res = generator->generateKeyPair(generator, NULL, &keyPair);
1102     EXPECT_EQ(res, HCF_SUCCESS);
1103     EXPECT_NE(keyPair, nullptr);
1104     EXPECT_NE(keyPair->priKey, nullptr);
1105     EXPECT_NE(keyPair->pubKey, nullptr);
1106 
1107     HcfCipher *cipher = NULL;
1108     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1109     EXPECT_EQ(res, HCF_SUCCESS);
1110 
1111     uint8_t plan[] = "12312123123";
1112     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1113 
1114     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, NULL);
1115     EXPECT_EQ(res, HCF_SUCCESS);
1116 
1117     HcfBlob blob;
1118     res = cipher->doFinal((HcfCipher *)generator, &input, &blob);
1119     EXPECT_NE(res, HCF_SUCCESS);
1120 
1121     HcfObjDestroy(keyPair);
1122     HcfObjDestroy(generator);
1123     HcfObjDestroy(cipher);
1124 }
1125 
1126 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest920, TestSize.Level0)
1127 {
1128     HcfResult res = HCF_SUCCESS;
1129     HcfCipher *cipher = NULL;
1130     res = HcfCipherCreate("RSA10|PK1", &cipher);
1131     EXPECT_NE(res, HCF_SUCCESS);
1132 }
1133 
1134 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest930, TestSize.Level0)
1135 {
1136     HcfResult res = HCF_SUCCESS;
1137     HcfCipher *cipher = NULL;
1138     res = HcfCipherCreate("RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|"
1139         "RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1", &cipher);
1140     EXPECT_NE(res, HCF_SUCCESS);
1141 }
1142 
1143 // incorrect : init Cipher twice
1144 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest940, TestSize.Level0)
1145 {
1146     HcfResult res = HCF_SUCCESS;
1147     HcfAsyKeyGenerator *generator = NULL;
1148     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1149     EXPECT_EQ(res, HCF_SUCCESS);
1150     HcfKeyPair *keyPair = NULL;
1151     res = generator->generateKeyPair(generator, NULL, &keyPair);
1152     EXPECT_EQ(res, HCF_SUCCESS);
1153 
1154     HcfCipher *cipher = NULL;
1155     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1156     EXPECT_EQ(res, HCF_SUCCESS);
1157     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
1158     EXPECT_EQ(res, HCF_SUCCESS);
1159     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, NULL);
1160     EXPECT_NE(res, HCF_SUCCESS);
1161 
1162     HcfObjDestroy(keyPair);
1163     HcfObjDestroy(generator);
1164     HcfObjDestroy(cipher);
1165 }
1166 }