1 /*
2  * Copyright (C) 2022-2023 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 
19 #include "asy_key_generator.h"
20 #include "asy_key_generator_spi.h"
21 #include "blob.h"
22 #include "memory.h"
23 #include "params_parser.h"
24 #include "rsa_asy_key_generator_openssl.h"
25 
26 using namespace std;
27 using namespace testing::ext;
28 
29 namespace {
30 class CryptoRsaAsyKeyGeneratorTest : public testing::Test {
31 public:
32     static void SetUpTestCase();
33     static void TearDownTestCase();
34     void SetUp();
35     void TearDown();
36 };
37 
SetUpTestCase()38 void CryptoRsaAsyKeyGeneratorTest::SetUpTestCase() {}
TearDownTestCase()39 void CryptoRsaAsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()40 void CryptoRsaAsyKeyGeneratorTest::SetUp() {}
TearDown()41 void CryptoRsaAsyKeyGeneratorTest::TearDown() {}
42 
43 constexpr int32_t OPENSSL_RSA_KEY_SIZE_2048 = 2048;
44 constexpr int32_t OPENSSL_RSA_KEY_SIZE_4096 = 4096;
45 constexpr int32_t OPENSSL_RSA_KEY_SIZE_ABNORMAL = 1;
46 constexpr int32_t OPENSSL_RSA_PRIMES_ABNORMAL = 1;
47 constexpr size_t RSA_CORRECT_PUBKEY_LEN = 162;
48 constexpr size_t RSA_ERROR_PUBKEY_LEN = 1;
49 uint8_t g_rsaCorrectPkData[] = {
50     48, 129, 159, 48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0, 3, 129, 141, 0, 48, 129,
51     137, 2, 129, 129, 0, 174, 203, 113, 83, 113, 3, 143, 213, 194, 79, 91, 9, 51, 142, 87, 45, 97,
52     65, 136, 24, 166, 35, 5, 179, 42, 47, 212, 79, 111, 74, 134, 120, 73, 67, 21, 19, 235, 80, 46,
53     152, 209, 133, 232, 87, 192, 140, 18, 206, 27, 106, 106, 169, 106, 46, 135, 111, 118, 32, 129,
54     27, 89, 255, 183, 116, 247, 38, 12, 7, 238, 77, 151, 167, 6, 102, 153, 126, 66, 28, 253, 253, 216,
55     64, 20, 138, 117, 72, 15, 216, 178, 37, 208, 179, 63, 204, 39, 94, 244, 170, 48, 190, 21, 11,
56     73, 169, 156, 104, 193, 3, 17, 100, 28, 60, 50, 92, 235, 218, 57, 73, 119, 19, 101, 164, 192,
57     161, 197, 106, 105, 73, 2, 3, 1, 0, 1
58 };
59 
60 HcfBlob g_rsaCorrectPubKeyBlob = {
61     .data = g_rsaCorrectPkData,
62     .len = RSA_CORRECT_PUBKEY_LEN
63 };
64 HcfBlob g_rsaErrorPubKeyBlob = {
65     .data = g_rsaCorrectPkData,
66     .len = RSA_ERROR_PUBKEY_LEN
67 };
68 
GetMockClass(void)69 static const char *GetMockClass(void)
70 {
71     return "HcfSymKeyGenerator";
72 }
73 
74 HcfObjectBase g_obj = {
75     .getClass = GetMockClass,
76     .destroy = nullptr
77 };
78 // HcfAsyKeyGeneratorCreate correct case: no primes
79 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest100, TestSize.Level0)
80 {
81     HcfAsyKeyGenerator *generator = nullptr;
82     HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
83     EXPECT_EQ(res, HCF_SUCCESS);
84     EXPECT_NE(generator, nullptr);
85     EXPECT_NE(generator->base.getClass(), nullptr);
86     EXPECT_NE(generator->base.destroy, nullptr);
87     EXPECT_NE(generator->generateKeyPair, nullptr);
88     EXPECT_NE(generator->getAlgoName, nullptr);
89     HcfObjDestroy(generator);
90 }
91 
92 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest110, TestSize.Level0)
93 {
94     HcfAsyKeyGenerator *generator = nullptr;
95     HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
96     EXPECT_EQ(res, HCF_SUCCESS);
97     EXPECT_NE(generator, nullptr);
98     EXPECT_NE(generator->base.getClass(), nullptr);
99     EXPECT_NE(generator->base.destroy, nullptr);
100     EXPECT_NE(generator->generateKeyPair, nullptr);
101     EXPECT_NE(generator->getAlgoName, nullptr);
102     HcfObjDestroy(generator);
103 }
104 
105 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest120, TestSize.Level0)
106 {
107     HcfAsyKeyGenerator *generator = nullptr;
108     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
109     EXPECT_EQ(res, HCF_SUCCESS);
110     EXPECT_NE(generator, nullptr);
111     EXPECT_NE(generator->base.getClass(), nullptr);
112     EXPECT_NE(generator->base.destroy, nullptr);
113     EXPECT_NE(generator->generateKeyPair, nullptr);
114     EXPECT_NE(generator->getAlgoName, nullptr);
115     HcfObjDestroy(generator);
116 }
117 
118 
119 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest130, TestSize.Level0)
120 {
121     HcfAsyKeyGenerator *generator = nullptr;
122     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
123     EXPECT_EQ(res, HCF_SUCCESS);
124     EXPECT_NE(generator, nullptr);
125     EXPECT_NE(generator->base.getClass(), nullptr);
126     EXPECT_NE(generator->base.destroy, nullptr);
127     EXPECT_NE(generator->generateKeyPair, nullptr);
128     EXPECT_NE(generator->getAlgoName, nullptr);
129     HcfObjDestroy(generator);
130 }
131 
132 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest140, TestSize.Level0)
133 {
134     HcfAsyKeyGenerator *generator = nullptr;
135     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
136     EXPECT_EQ(res, HCF_SUCCESS);
137     EXPECT_NE(generator, nullptr);
138     EXPECT_NE(generator->base.getClass(), nullptr);
139     EXPECT_NE(generator->base.destroy, nullptr);
140     EXPECT_NE(generator->generateKeyPair, nullptr);
141     EXPECT_NE(generator->getAlgoName, nullptr);
142     HcfObjDestroy(generator);
143 }
144 
145 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest150, TestSize.Level0)
146 {
147     HcfAsyKeyGenerator *generator = nullptr;
148     HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
149     EXPECT_EQ(res, HCF_SUCCESS);
150     EXPECT_NE(generator, nullptr);
151     EXPECT_NE(generator->base.getClass(), nullptr);
152     EXPECT_NE(generator->base.destroy, nullptr);
153     EXPECT_NE(generator->generateKeyPair, nullptr);
154     EXPECT_NE(generator->getAlgoName, nullptr);
155     HcfObjDestroy(generator);
156 }
157 
158 // HcfAsyKeyGeneratorCreate correct case: with primes
159 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest200, TestSize.Level0)
160 {
161     HcfAsyKeyGenerator *generator = nullptr;
162     HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_2", &generator);
163     EXPECT_EQ(res, HCF_SUCCESS);
164     EXPECT_NE(generator, nullptr);
165     EXPECT_NE(generator->base.getClass(), nullptr);
166     EXPECT_NE(generator->base.destroy, nullptr);
167     EXPECT_NE(generator->generateKeyPair, nullptr);
168     EXPECT_NE(generator->getAlgoName, nullptr);
169     HcfObjDestroy(generator);
170 }
171 
172 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest210, TestSize.Level0)
173 {
174     HcfAsyKeyGenerator *generator = nullptr;
175     HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator);
176     EXPECT_EQ(res, HCF_SUCCESS);
177     EXPECT_NE(generator, nullptr);
178     EXPECT_NE(generator->base.getClass(), nullptr);
179     EXPECT_NE(generator->base.destroy, nullptr);
180     EXPECT_NE(generator->generateKeyPair, nullptr);
181     EXPECT_NE(generator->getAlgoName, nullptr);
182     HcfObjDestroy(generator);
183 }
184 
185 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest220, TestSize.Level0)
186 {
187     HcfAsyKeyGenerator *generator = nullptr;
188     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
189     EXPECT_EQ(res, HCF_SUCCESS);
190     EXPECT_NE(generator, nullptr);
191     EXPECT_NE(generator->base.getClass(), nullptr);
192     EXPECT_NE(generator->base.destroy, nullptr);
193     EXPECT_NE(generator->generateKeyPair, nullptr);
194     EXPECT_NE(generator->getAlgoName, nullptr);
195     HcfObjDestroy(generator);
196 }
197 
198 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest230, TestSize.Level0)
199 {
200     HcfAsyKeyGenerator *generator = nullptr;
201     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
202     EXPECT_EQ(res, HCF_SUCCESS);
203     EXPECT_NE(generator, nullptr);
204     EXPECT_NE(generator->base.getClass(), nullptr);
205     EXPECT_NE(generator->base.destroy, nullptr);
206     EXPECT_NE(generator->generateKeyPair, nullptr);
207     EXPECT_NE(generator->getAlgoName, nullptr);
208     HcfObjDestroy(generator);
209 }
210 
211 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest240, TestSize.Level0)
212 {
213     HcfAsyKeyGenerator *generator = nullptr;
214     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
215     EXPECT_EQ(res, HCF_SUCCESS);
216     EXPECT_NE(generator, nullptr);
217     EXPECT_NE(generator->base.getClass(), nullptr);
218     EXPECT_NE(generator->base.destroy, nullptr);
219     EXPECT_NE(generator->generateKeyPair, nullptr);
220     EXPECT_NE(generator->getAlgoName, nullptr);
221     HcfObjDestroy(generator);
222 }
223 
224 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest250, TestSize.Level0)
225 {
226     HcfAsyKeyGenerator *generator = nullptr;
227     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator);
228     EXPECT_EQ(res, HCF_SUCCESS);
229     EXPECT_NE(generator, nullptr);
230     EXPECT_NE(generator->base.getClass(), nullptr);
231     EXPECT_NE(generator->base.destroy, nullptr);
232     EXPECT_NE(generator->generateKeyPair, nullptr);
233     EXPECT_NE(generator->getAlgoName, nullptr);
234     HcfObjDestroy(generator);
235 }
236 
237 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest260, TestSize.Level0)
238 {
239     HcfAsyKeyGenerator *generator = nullptr;
240     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
241     EXPECT_EQ(res, HCF_SUCCESS);
242     EXPECT_NE(generator, nullptr);
243     EXPECT_NE(generator->base.getClass(), nullptr);
244     EXPECT_NE(generator->base.destroy, nullptr);
245     EXPECT_NE(generator->generateKeyPair, nullptr);
246     EXPECT_NE(generator->getAlgoName, nullptr);
247     HcfObjDestroy(generator);
248 }
249 
250 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest270, TestSize.Level0)
251 {
252     HcfAsyKeyGenerator *generator = nullptr;
253     HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_4", &generator);
254     EXPECT_EQ(res, HCF_SUCCESS);
255     EXPECT_NE(generator, nullptr);
256     EXPECT_NE(generator->base.getClass(), nullptr);
257     EXPECT_NE(generator->base.destroy, nullptr);
258     EXPECT_NE(generator->generateKeyPair, nullptr);
259     EXPECT_NE(generator->getAlgoName, nullptr);
260     HcfObjDestroy(generator);
261 }
262 
263 // HcfAsyKeyGeneratorCreate Incorrect case : algname is null
264 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest300, TestSize.Level0)
265 {
266     HcfAsyKeyGenerator *generator = nullptr;
267     HcfResult res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
268     EXPECT_NE(res, HCF_SUCCESS);
269     EXPECT_EQ(generator, nullptr);
270     HcfObjDestroy(generator);
271 }
272 
273 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest301, TestSize.Level0)
274 {
275     HcfAsyKeyGenerator *generator = nullptr;
276     HcfResult res = HcfAsyKeyGeneratorCreate("", &generator);
277     EXPECT_NE(res, HCF_SUCCESS);
278 }
279 
280 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest310, TestSize.Level0)
281 {
282     HcfAsyKeyGenerator *generator = nullptr;
283     HcfResult res = HcfAsyKeyGeneratorCreate("111111111111111111111111111111111111111111111111111111111111111111111111"
284         "111111111111111111111111111111111111111111111111111111111111111111111", &generator);
285     EXPECT_NE(res, HCF_SUCCESS);
286     EXPECT_EQ(generator, nullptr);
287     HcfObjDestroy(generator);
288 }
289 
290 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest320, TestSize.Level0)
291 {
292     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", nullptr);
293     EXPECT_NE(res, HCF_SUCCESS);
294 }
295 
296 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest330, TestSize.Level0)
297 {
298     HcfAsyKeyGenerator *generator = nullptr;
299     HcfResult res = HcfAsyKeyGeneratorCreate("RSA12315", &generator);
300     EXPECT_NE(res, HCF_SUCCESS);
301     EXPECT_EQ(generator, nullptr);
302     HcfObjDestroy(generator);
303 }
304 
305 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest340, TestSize.Level0)
306 {
307     HcfAsyKeyGenerator *generator = nullptr;
308     HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_777", &generator);
309     EXPECT_NE(res, HCF_SUCCESS);
310     EXPECT_EQ(generator, nullptr);
311     HcfObjDestroy(generator);
312 }
313 
314 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest350, TestSize.Level0)
315 {
316     HcfAsyKeyGenerator *generator = nullptr;
317     HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_3", &generator);
318     EXPECT_NE(res, HCF_SUCCESS);
319     EXPECT_EQ(generator, nullptr);
320     HcfObjDestroy(generator);
321 }
322 
323 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest360, TestSize.Level0)
324 {
325     HcfAsyKeyGenerator *generator = nullptr;
326     HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_3", &generator);
327     EXPECT_NE(res, HCF_SUCCESS);
328     EXPECT_EQ(generator, nullptr);
329     HcfObjDestroy(generator);
330 }
331 
332 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest370, TestSize.Level0)
333 {
334     HcfAsyKeyGenerator *generator = nullptr;
335     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_4", &generator);
336     EXPECT_NE(res, HCF_SUCCESS);
337     EXPECT_EQ(generator, nullptr);
338     HcfObjDestroy(generator);
339 }
340 
341 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest380, TestSize.Level0)
342 {
343     HcfAsyKeyGenerator *generator = nullptr;
344     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_4", &generator);
345     EXPECT_NE(res, HCF_SUCCESS);
346     EXPECT_EQ(generator, nullptr);
347     HcfObjDestroy(generator);
348 }
349 
350 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest381, TestSize.Level0)
351 {
352     HcfAsyKeyGenerator *generator = nullptr;
353     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
354     EXPECT_EQ(res, HCF_SUCCESS);
355     EXPECT_NE(generator, nullptr);
356     HcfObjDestroy(generator);
357 }
358 
359 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest390, TestSize.Level0)
360 {
361     HcfAsyKeyGenerator *generator = nullptr;
362     HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_5", &generator);
363     EXPECT_NE(res, HCF_SUCCESS);
364     EXPECT_EQ(generator, nullptr);
365     HcfObjDestroy(generator);
366 }
367 
368 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest391, TestSize.Level0)
369 {
370     HcfAsyKeyGenerator *generator = nullptr;
371     HcfResult res = HcfAsyKeyGeneratorCreate("RSA8192|PRIMES_5", &generator);
372     EXPECT_EQ(res, HCF_SUCCESS);
373     EXPECT_NE(generator, nullptr);
374     HcfObjDestroy(generator);
375 }
376 
377 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest400, TestSize.Level0)
378 {
379     HcfAsyKeyGenerator *generator = nullptr;
380     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
381     EXPECT_EQ(res, HCF_SUCCESS);
382     EXPECT_NE(generator, nullptr);
383     HcfObjDestroy(generator);
384     generator = nullptr;
385     HcfObjDestroy(generator);
386     HcfObjDestroy(nullptr);
387 }
388 
389 // generateKeyPair correct case
390 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest500, TestSize.Level0)
391 {
392     HcfAsyKeyGenerator *generator = nullptr;
393     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
394 
395     HcfKeyPair *keyPair = nullptr;
396     res = generator->generateKeyPair(generator, nullptr, &keyPair);
397 
398     EXPECT_EQ(res, HCF_SUCCESS);
399     EXPECT_NE(keyPair, nullptr);
400     EXPECT_NE(keyPair->priKey, nullptr);
401     EXPECT_NE(keyPair->pubKey, nullptr);
402     EXPECT_NE(keyPair->base.getClass(), nullptr);
403     EXPECT_NE(keyPair->base.destroy, nullptr);
404 
405     HcfPubKey *pubkey = keyPair->pubKey;
406     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
407     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
408     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
409     EXPECT_NE(pubkey->base.base.destroy, nullptr);
410 
411     HcfPriKey *prikey = keyPair->priKey;
412     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
413     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
414     EXPECT_NE(prikey->base.base.getClass(), nullptr);
415     EXPECT_NE(prikey->base.base.destroy, nullptr);
416     EXPECT_NE(prikey->clearMem, nullptr);
417 
418     HcfObjDestroy(keyPair);
419     HcfObjDestroy(generator);
420 }
421 
422 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest510, TestSize.Level0)
423 {
424     HcfAsyKeyGenerator *generator = nullptr;
425     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
426 
427     HcfKeyPair *keyPair = nullptr;
428     res = generator->generateKeyPair(generator, nullptr, &keyPair);
429 
430     EXPECT_EQ(res, HCF_SUCCESS);
431     EXPECT_NE(keyPair, nullptr);
432     EXPECT_NE(keyPair->priKey, nullptr);
433     EXPECT_NE(keyPair->pubKey, nullptr);
434     EXPECT_NE(keyPair->base.getClass(), nullptr);
435     EXPECT_NE(keyPair->base.destroy, nullptr);
436 
437     HcfPubKey *pubkey = keyPair->pubKey;
438     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
439     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
440     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
441     EXPECT_NE(pubkey->base.base.destroy, nullptr);
442 
443     HcfPriKey *prikey = keyPair->priKey;
444     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
445     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
446     EXPECT_NE(prikey->base.base.getClass(), nullptr);
447     EXPECT_NE(prikey->base.base.destroy, nullptr);
448     EXPECT_NE(prikey->clearMem, nullptr);
449 
450     HcfObjDestroy(keyPair);
451     HcfObjDestroy(generator);
452 }
453 
454 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest511, TestSize.Level0)
455 {
456     HcfAsyKeyGenerator *generator = nullptr;
457     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator);
458 
459     HcfKeyPair *keyPair = nullptr;
460     res = generator->generateKeyPair(generator, nullptr, &keyPair);
461 
462     HcfBlob pubKeyBlob;
463     HcfBlob priKeyBlob;
464     HcfPubKey *pubKey = keyPair->pubKey;
465     HcfPriKey *priKey = keyPair->priKey;
466 
467     res = pubKey->base.getEncoded((HcfKey *)priKey, &pubKeyBlob);
468     EXPECT_NE(res, HCF_SUCCESS);
469     res = priKey->base.getEncoded((HcfKey *)pubKey, &priKeyBlob);
470     EXPECT_NE(res, HCF_SUCCESS);
471     HcfObjDestroy(keyPair);
472     HcfObjDestroy(generator);
473     HcfFree(pubKeyBlob.data);
474     HcfFree(priKeyBlob.data);
475 }
476 
477 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0)
478 {
479     HcfAsyKeyGenerator *generator = nullptr;
480     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
481 
482     HcfKeyPair *keyPair = nullptr;
483     res = generator->generateKeyPair(generator, nullptr, &keyPair);
484 
485     HcfPubKey *pubKey = keyPair->pubKey;
486     HcfPriKey *priKey = keyPair->priKey;
487 
488     res = pubKey->base.getEncoded((HcfKey *)priKey, nullptr);
489     EXPECT_NE(res, HCF_SUCCESS);
490     res = priKey->base.getEncoded((HcfKey *)pubKey, nullptr);
491     EXPECT_NE(res, HCF_SUCCESS);
492     HcfObjDestroy(keyPair);
493     HcfObjDestroy(generator);
494 }
495 
496 // generateKeyPair conrrect case: use getEncode encode pubkey and prikey
497 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize.Level0)
498 {
499     HcfAsyKeyGenerator *generator = nullptr;
500     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
501     EXPECT_EQ(res, HCF_SUCCESS);
502     EXPECT_NE(generator, nullptr);
503 
504     HcfKeyPair *keyPair = nullptr;
505     res = generator->generateKeyPair(generator, nullptr, &keyPair);
506     EXPECT_EQ(res, HCF_SUCCESS);
507     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
508     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
509     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
510     EXPECT_EQ(res, HCF_SUCCESS);
511     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
512     EXPECT_EQ(res, HCF_SUCCESS);
513 
514     HcfKeyPair *dupKeyPair = nullptr;
515     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
516     EXPECT_EQ(res, HCF_SUCCESS);
517     HcfPubKey *pubkey = dupKeyPair->pubKey;
518     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
519     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
520     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
521     EXPECT_NE(pubkey->base.base.destroy, nullptr);
522 
523     HcfPriKey *prikey = dupKeyPair->priKey;
524     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
525     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
526     EXPECT_NE(prikey->base.base.getClass(), nullptr);
527     EXPECT_NE(prikey->base.base.destroy, nullptr);
528     EXPECT_NE(prikey->clearMem, nullptr);
529 
530     HcfFree(pubKeyBlob.data);
531     HcfFree(priKeyBlob.data);
532     HcfObjDestroy(generator);
533     HcfObjDestroy(keyPair);
534     HcfObjDestroy(dupKeyPair);
535 }
536 
537 // Test muliti getEncoded and convertKey
538 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest521, TestSize.Level0)
539 {
540     HcfAsyKeyGenerator *generator = nullptr;
541     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
542     EXPECT_EQ(res, HCF_SUCCESS);
543     EXPECT_NE(generator, nullptr);
544 
545     HcfKeyPair *keyPair = nullptr;
546     res = generator->generateKeyPair(generator, nullptr, &keyPair);
547     EXPECT_EQ(res, HCF_SUCCESS);
548     HcfBlob pubKeyBlob1 = {.data = nullptr, .len = 0};
549     HcfBlob priKeyBlob1 = {.data = nullptr, .len = 0};
550     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob1);
551     EXPECT_EQ(res, HCF_SUCCESS);
552     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob1);
553     EXPECT_EQ(res, HCF_SUCCESS);
554 
555     HcfKeyPair *dupKeyPair1 = nullptr;
556     res = generator->convertKey(generator, nullptr, &pubKeyBlob1, &priKeyBlob1, &dupKeyPair1);
557     EXPECT_EQ(res, HCF_SUCCESS);
558 
559     HcfKeyPair *dupKeyPair2 = nullptr;
560     HcfBlob pubKeyBlob2 = {.data = nullptr, .len = 0};
561     HcfBlob priKeyBlob2 = {.data = nullptr, .len = 0};
562     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob2);
563     EXPECT_EQ(res, HCF_SUCCESS);
564     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob2);
565     EXPECT_EQ(res, HCF_SUCCESS);
566     res = generator->convertKey(generator, nullptr, &pubKeyBlob2, &priKeyBlob2, &dupKeyPair2);
567     EXPECT_EQ(res, HCF_SUCCESS);
568 
569     HcfFree(pubKeyBlob1.data);
570     HcfFree(priKeyBlob1.data);
571     HcfFree(pubKeyBlob2.data);
572     HcfFree(priKeyBlob2.data);
573     HcfObjDestroy(generator);
574     HcfObjDestroy(keyPair);
575     HcfObjDestroy(dupKeyPair1);
576     HcfObjDestroy(dupKeyPair2);
577 }
578 
579 // generateKeyPair correct case: getEncode encode pubkey
580 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize.Level0)
581 {
582     HcfAsyKeyGenerator *generator = nullptr;
583     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
584     EXPECT_EQ(res, HCF_SUCCESS);
585     EXPECT_NE(generator, nullptr);
586 
587     HcfKeyPair *keyPair = nullptr;
588     res = generator->generateKeyPair(generator, nullptr, &keyPair);
589     EXPECT_EQ(res, HCF_SUCCESS);
590     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
591     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
592     EXPECT_EQ(res, HCF_SUCCESS);
593 
594     HcfKeyPair *dupKeyPair = nullptr;
595     res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &dupKeyPair);
596     EXPECT_EQ(res, HCF_SUCCESS);
597     HcfPubKey *pubkey = dupKeyPair->pubKey;
598     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
599     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
600     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
601     EXPECT_NE(pubkey->base.base.destroy, nullptr);
602 
603     HcfFree(pubKeyBlob.data);
604     HcfObjDestroy(generator);
605     HcfObjDestroy(keyPair);
606     HcfObjDestroy(dupKeyPair);
607 }
608 
609 // generateKeyPair correct case: getEncode encode prikey
610 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize.Level0)
611 {
612     HcfAsyKeyGenerator *generator = nullptr;
613     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
614     EXPECT_EQ(res, HCF_SUCCESS);
615     EXPECT_NE(generator, nullptr);
616 
617     HcfKeyPair *keyPair = nullptr;
618     res = generator->generateKeyPair(generator, nullptr, &keyPair);
619     EXPECT_EQ(res, HCF_SUCCESS);
620     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
621     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
622     EXPECT_EQ(res, HCF_SUCCESS);
623 
624     HcfKeyPair *dupKeyPair = nullptr;
625     res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
626     EXPECT_EQ(res, HCF_SUCCESS);
627 
628     HcfPriKey *prikey = dupKeyPair->priKey;
629     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
630     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
631     EXPECT_NE(prikey->base.base.getClass(), nullptr);
632     EXPECT_NE(prikey->base.base.destroy, nullptr);
633     EXPECT_NE(prikey->clearMem, nullptr);
634 
635     HcfFree(priKeyBlob.data);
636     HcfObjDestroy(generator);
637     HcfObjDestroy(keyPair);
638     HcfObjDestroy(dupKeyPair);
639 }
640 
641 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize.Level0)
642 {
643     HcfAsyKeyGenerator *generator = nullptr;
644     HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
645     EXPECT_EQ(res, HCF_SUCCESS);
646     EXPECT_NE(generator, nullptr);
647 
648     HcfKeyPair *keyPair = nullptr;
649     res = generator->generateKeyPair(generator, nullptr, &keyPair);
650     EXPECT_EQ(res, HCF_SUCCESS);
651     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
652     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
653     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
654     EXPECT_EQ(res, HCF_SUCCESS);
655     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
656     EXPECT_EQ(res, HCF_SUCCESS);
657 
658     HcfKeyPair *dupKeyPair = nullptr;
659     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
660     EXPECT_EQ(res, HCF_SUCCESS);
661     HcfPubKey *pubkey = dupKeyPair->pubKey;
662     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
663     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
664     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
665     EXPECT_NE(pubkey->base.base.destroy, nullptr);
666 
667     HcfPriKey *prikey = dupKeyPair->priKey;
668     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
669     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
670     EXPECT_NE(prikey->base.base.getClass(), nullptr);
671     EXPECT_NE(prikey->base.base.destroy, nullptr);
672     EXPECT_NE(prikey->clearMem, nullptr);
673 
674     HcfFree(pubKeyBlob.data);
675     HcfFree(priKeyBlob.data);
676     HcfObjDestroy(generator);
677     HcfObjDestroy(keyPair);
678     HcfObjDestroy(dupKeyPair);
679 }
680 
681 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize.Level0)
682 {
683     HcfAsyKeyGenerator *generator = nullptr;
684     HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
685     EXPECT_EQ(res, HCF_SUCCESS);
686     EXPECT_NE(generator, nullptr);
687 
688     HcfKeyPair *keyPair = nullptr;
689     res = generator->generateKeyPair(generator, nullptr, &keyPair);
690     EXPECT_EQ(res, HCF_SUCCESS);
691     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
692     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
693     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
694     EXPECT_EQ(res, HCF_SUCCESS);
695     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
696     EXPECT_EQ(res, HCF_SUCCESS);
697 
698     HcfKeyPair *dupKeyPair = nullptr;
699     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
700     EXPECT_EQ(res, HCF_SUCCESS);
701     HcfPubKey *pubkey = dupKeyPair->pubKey;
702     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
703     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
704     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
705     EXPECT_NE(pubkey->base.base.destroy, nullptr);
706 
707     HcfPriKey *prikey = dupKeyPair->priKey;
708     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
709     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
710     EXPECT_NE(prikey->base.base.getClass(), nullptr);
711     EXPECT_NE(prikey->base.base.destroy, nullptr);
712     EXPECT_NE(prikey->clearMem, nullptr);
713 
714     HcfFree(pubKeyBlob.data);
715     HcfFree(priKeyBlob.data);
716     HcfObjDestroy(generator);
717     HcfObjDestroy(keyPair);
718     HcfObjDestroy(dupKeyPair);
719 }
720 
721 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize.Level0)
722 {
723     HcfAsyKeyGenerator *generator = nullptr;
724     HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
725     EXPECT_EQ(res, HCF_SUCCESS);
726     EXPECT_NE(generator, nullptr);
727 
728     HcfKeyPair *keyPair = nullptr;
729     res = generator->generateKeyPair(generator, nullptr, &keyPair);
730     EXPECT_EQ(res, HCF_SUCCESS);
731     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
732     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
733     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
734     EXPECT_EQ(res, HCF_SUCCESS);
735     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
736     EXPECT_EQ(res, HCF_SUCCESS);
737 
738     HcfKeyPair *dupKeyPair = nullptr;
739     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
740     EXPECT_EQ(res, HCF_SUCCESS);
741     HcfPubKey *pubkey = dupKeyPair->pubKey;
742     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
743     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
744     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
745     EXPECT_NE(pubkey->base.base.destroy, nullptr);
746 
747     HcfPriKey *prikey = dupKeyPair->priKey;
748     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
749     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
750     EXPECT_NE(prikey->base.base.getClass(), nullptr);
751     EXPECT_NE(prikey->base.base.destroy, nullptr);
752     EXPECT_NE(prikey->clearMem, nullptr);
753 
754     HcfFree(pubKeyBlob.data);
755     HcfFree(priKeyBlob.data);
756     HcfObjDestroy(generator);
757     HcfObjDestroy(keyPair);
758     HcfObjDestroy(dupKeyPair);
759 }
760 
761 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize.Level0)
762 {
763     HcfAsyKeyGenerator *generator = nullptr;
764     HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
765     EXPECT_EQ(res, HCF_SUCCESS);
766     EXPECT_NE(generator, nullptr);
767 
768     HcfKeyPair *keyPair = nullptr;
769     res = generator->generateKeyPair(generator, nullptr, &keyPair);
770     EXPECT_EQ(res, HCF_SUCCESS);
771     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
772     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
773     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
774     EXPECT_EQ(res, HCF_SUCCESS);
775     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
776     EXPECT_EQ(res, HCF_SUCCESS);
777 
778     HcfKeyPair *dupKeyPair = nullptr;
779     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
780     EXPECT_EQ(res, HCF_SUCCESS);
781     HcfPubKey *pubkey = dupKeyPair->pubKey;
782     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
783     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
784     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
785     EXPECT_NE(pubkey->base.base.destroy, nullptr);
786 
787     HcfPriKey *prikey = dupKeyPair->priKey;
788     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
789     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
790     EXPECT_NE(prikey->base.base.getClass(), nullptr);
791     EXPECT_NE(prikey->base.base.destroy, nullptr);
792     EXPECT_NE(prikey->clearMem, nullptr);
793 
794     HcfFree(pubKeyBlob.data);
795     HcfFree(priKeyBlob.data);
796     HcfObjDestroy(generator);
797     HcfObjDestroy(keyPair);
798     HcfObjDestroy(dupKeyPair);
799 }
800 
801 // generateKeyPair incorrect case: user wrong ECC class, ignore in this version
802 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest600, TestSize.Level0)
803 {
804     HcfAsyKeyGenerator *eccGenerator = nullptr;
805     HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
806     EXPECT_EQ(res, HCF_SUCCESS);
807     EXPECT_NE(eccGenerator, nullptr);
808 
809     HcfAsyKeyGenerator *rsaGenerator = nullptr;
810     res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
811     EXPECT_EQ(res, HCF_SUCCESS);
812     EXPECT_NE(rsaGenerator, nullptr);
813 
814     HcfKeyPair *keyPair = nullptr;
815     // innerkit调用，在framework层中，指针无法判断eccGenerator调用的self，所以keypair实际不为空。
816     // 会调到ecc的generatekeyPair，生成ecc的keypair对象（class为ecckeypair）
817     // 对js调用，能否防范？
818     res = rsaGenerator->generateKeyPair(eccGenerator, nullptr, &keyPair);
819     // 经验证，keypair不为空,且为ecc的keypair
820     EXPECT_NE(keyPair, nullptr);
821     EXPECT_STREQ("OPENSSL.ECC.KEY_PAIR", keyPair->base.getClass());
822 
823     HcfObjDestroy(keyPair);
824     HcfObjDestroy(eccGenerator);
825     HcfObjDestroy(rsaGenerator);
826 }
827 
828 // generateKeyPair incorrect case: generator class is null
829 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest610, TestSize.Level0)
830 {
831     HcfAsyKeyGenerator *rsaGenerator = nullptr;
832     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
833     EXPECT_EQ(res, HCF_SUCCESS);
834     EXPECT_NE(rsaGenerator, nullptr);
835 
836     HcfKeyPair *keyPair = nullptr;
837     res = rsaGenerator->generateKeyPair(nullptr, nullptr, &keyPair);
838     EXPECT_NE(res, HCF_SUCCESS);
839     EXPECT_EQ(keyPair, nullptr);
840 
841     HcfObjDestroy(rsaGenerator);
842 }
843 
844 // generateKeyPair incorrect case: keypair is null
845 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest620, TestSize.Level0)
846 {
847     HcfAsyKeyGenerator *rsaGenerator = nullptr;
848     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
849     EXPECT_EQ(res, HCF_SUCCESS);
850     EXPECT_NE(rsaGenerator, nullptr);
851 
852     res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, nullptr);
853     EXPECT_NE(res, HCF_SUCCESS);
854 
855     HcfObjDestroy(rsaGenerator);
856 }
857 
858 // convertKey correct case
859 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize.Level0)
860 {
861     HcfAsyKeyGenerator *generator = nullptr;
862     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
863     EXPECT_EQ(res, HCF_SUCCESS);
864     EXPECT_NE(generator, nullptr);
865 
866     HcfKeyPair *keyPair = nullptr;
867     res = generator->generateKeyPair(generator, nullptr, &keyPair);
868     EXPECT_EQ(res, HCF_SUCCESS);
869     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
870     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
871     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
872     EXPECT_EQ(res, HCF_SUCCESS);
873     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
874     EXPECT_EQ(res, HCF_SUCCESS);
875 
876     HcfKeyPair *dupKeyPair = nullptr;
877     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
878     EXPECT_EQ(res, HCF_SUCCESS);
879     HcfPubKey *pubkey = dupKeyPair->pubKey;
880     EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
881     EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
882     EXPECT_NE(pubkey->base.base.getClass(), nullptr);
883     EXPECT_NE(pubkey->base.base.destroy, nullptr);
884 
885     HcfPriKey *prikey = dupKeyPair->priKey;
886     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
887     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
888     EXPECT_NE(prikey->base.base.getClass(), nullptr);
889     EXPECT_NE(prikey->base.base.destroy, nullptr);
890     EXPECT_NE(prikey->clearMem, nullptr);
891 
892     HcfFree(pubKeyBlob.data);
893     HcfFree(priKeyBlob.data);
894     HcfObjDestroy(generator);
895     HcfObjDestroy(keyPair);
896     HcfObjDestroy(dupKeyPair);
897 }
898 
899 // convertKey incorrect case: input ECC class
900 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest710, TestSize.Level0)
901 {
902     HcfAsyKeyGenerator *eccGenerator = nullptr;
903     HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
904     EXPECT_EQ(res, HCF_SUCCESS);
905     EXPECT_NE(eccGenerator, nullptr);
906 
907     HcfAsyKeyGenerator *rsaGenerator = nullptr;
908     res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
909     EXPECT_EQ(res, HCF_SUCCESS);
910     EXPECT_NE(rsaGenerator, nullptr);
911 
912     HcfKeyPair *dupKeyPair = nullptr;
913     res = rsaGenerator->convertKey(eccGenerator, nullptr, nullptr, nullptr, &dupKeyPair);
914     EXPECT_NE(res, HCF_SUCCESS);
915     EXPECT_EQ(dupKeyPair, nullptr);
916 
917     HcfObjDestroy(eccGenerator);
918     HcfObjDestroy(rsaGenerator);
919 }
920 
921 
922 // convertKey incorrect case: input null generator
923 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest720, TestSize.Level0)
924 {
925     HcfAsyKeyGenerator *rsaGenerator = nullptr;
926     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
927     EXPECT_EQ(res, HCF_SUCCESS);
928     EXPECT_NE(rsaGenerator, nullptr);
929 
930     HcfKeyPair *keyPair = nullptr;
931     res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair);
932     EXPECT_EQ(res, HCF_SUCCESS);
933     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
934     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
935     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
936     EXPECT_EQ(res, HCF_SUCCESS);
937     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
938     EXPECT_EQ(res, HCF_SUCCESS);
939 
940     HcfKeyPair *dupKeyPair = nullptr;
941     res = rsaGenerator->convertKey(nullptr, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
942     EXPECT_NE(res, HCF_SUCCESS);
943     EXPECT_EQ(dupKeyPair, nullptr);
944 
945     HcfFree(pubKeyBlob.data);
946     HcfFree(priKeyBlob.data);
947     HcfObjDestroy(keyPair);
948     HcfObjDestroy(rsaGenerator);
949 }
950 
951 // convertKey incorrect case: input null dupkeypair
952 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest730, TestSize.Level0)
953 {
954     HcfAsyKeyGenerator *rsaGenerator = nullptr;
955     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
956     EXPECT_EQ(res, HCF_SUCCESS);
957     EXPECT_NE(rsaGenerator, nullptr);
958 
959     HcfKeyPair *keyPair = nullptr;
960     res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair);
961     EXPECT_EQ(res, HCF_SUCCESS);
962     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
963     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
964     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
965     EXPECT_EQ(res, HCF_SUCCESS);
966     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
967     EXPECT_EQ(res, HCF_SUCCESS);
968 
969     HcfKeyPair *dupKeyPair = nullptr;
970     res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, nullptr);
971     EXPECT_NE(res, HCF_SUCCESS);
972     EXPECT_EQ(dupKeyPair, nullptr);
973 
974     HcfFree(pubKeyBlob.data);
975     HcfFree(priKeyBlob.data);
976     HcfObjDestroy(keyPair);
977     HcfObjDestroy(rsaGenerator);
978 }
979 
980 // convertKey incorrect case: input blob with null data
981 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest740, TestSize.Level0)
982 {
983     HcfAsyKeyGenerator *rsaGenerator = nullptr;
984     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
985     EXPECT_EQ(res, HCF_SUCCESS);
986     EXPECT_NE(rsaGenerator, nullptr);
987 
988     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
989     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
990 
991     HcfKeyPair *dupKeyPair = nullptr;
992     res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
993     EXPECT_NE(res, HCF_SUCCESS);
994     EXPECT_EQ(dupKeyPair, nullptr);
995 
996     HcfObjDestroy(rsaGenerator);
997 }
998 
999 // convertKey incorrect case: input blob with zero len
1000 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest750, TestSize.Level0)
1001 {
1002     HcfAsyKeyGenerator *rsaGenerator = nullptr;
1003     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &rsaGenerator);
1004     EXPECT_EQ(res, HCF_SUCCESS);
1005     EXPECT_NE(rsaGenerator, nullptr);
1006 
1007     HcfBlob pubKeyBlob = {.data = g_rsaCorrectPkData, .len = 0};
1008     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1009 
1010     HcfKeyPair *dupKeyPair = nullptr;
1011     res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
1012     EXPECT_NE(res, HCF_SUCCESS);
1013     EXPECT_EQ(dupKeyPair, nullptr);
1014 
1015     HcfObjDestroy(rsaGenerator);
1016 }
1017 
1018 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest760, TestSize.Level0)
1019 {
1020     HcfAsyKeyGenerator *rsaGenerator = nullptr;
1021     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &rsaGenerator);
1022     EXPECT_EQ(res, HCF_SUCCESS);
1023     EXPECT_NE(rsaGenerator, nullptr);
1024 
1025     HcfBlob priKeyBlob = {.data = g_rsaCorrectPkData, .len = 0};
1026 
1027     HcfKeyPair *dupKeyPair = nullptr;
1028     res = rsaGenerator->convertKey(rsaGenerator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
1029     EXPECT_NE(res, HCF_SUCCESS);
1030     EXPECT_EQ(dupKeyPair, nullptr);
1031 
1032     HcfObjDestroy(rsaGenerator);
1033 }
1034 
1035 // convertKey incorrect case: input blob with error data
1036 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest770, TestSize.Level0)
1037 {
1038     HcfAsyKeyGenerator *rsaGenerator = nullptr;
1039     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
1040     EXPECT_EQ(res, HCF_SUCCESS);
1041     EXPECT_NE(rsaGenerator, nullptr);
1042 
1043     HcfKeyPair *dupKeyPair = nullptr;
1044     res = rsaGenerator->convertKey(rsaGenerator, nullptr, &g_rsaErrorPubKeyBlob, &g_rsaErrorPubKeyBlob, &dupKeyPair);
1045     EXPECT_NE(res, HCF_SUCCESS);
1046     EXPECT_EQ(dupKeyPair, nullptr);
1047 
1048     HcfObjDestroy(rsaGenerator);
1049 }
1050 
1051 // Incorrect case: use wrong bits or primes
1052 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest800, TestSize.Level0)
1053 {
1054     HcfAsyKeyGenerator *generator = nullptr;
1055     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1111", &generator);
1056     EXPECT_NE(res, HCF_SUCCESS);
1057     EXPECT_EQ(generator, nullptr);
1058     HcfObjDestroy(generator);
1059 }
1060 
1061 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest810, TestSize.Level0)
1062 {
1063     HcfAsyKeyGenerator *generator = nullptr;
1064     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
1065     EXPECT_NE(res, HCF_SUCCESS);
1066     EXPECT_EQ(generator, nullptr);
1067     HcfObjDestroy(generator);
1068 }
1069 
1070 // 测试异常释放
1071 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest820, TestSize.Level0)
1072 {
1073     HcfAsyKeyGenerator *generator = nullptr;
1074     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
1075     EXPECT_NE(res, HCF_SUCCESS);
1076     EXPECT_EQ(generator, nullptr);
1077     HcfObjDestroy(generator);
1078 }
1079 
1080 // prikey clear mem
1081 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest830, TestSize.Level0)
1082 {
1083     HcfAsyKeyGenerator *generator = nullptr;
1084     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1085     EXPECT_EQ(res, HCF_SUCCESS);
1086     EXPECT_NE(generator, nullptr);
1087 
1088     HcfKeyPair *keyPair = nullptr;
1089     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1090 
1091     keyPair->priKey->clearMem(nullptr);
1092 
1093     HcfObjDestroy(generator);
1094     HcfObjDestroy(keyPair);
1095 }
1096 
1097 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest840, TestSize.Level0)
1098 {
1099     HcfAsyKeyGenerator *generator = nullptr;
1100     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1101     EXPECT_EQ(res, HCF_SUCCESS);
1102     EXPECT_NE(generator, nullptr);
1103 
1104     HcfKeyPair *keyPair = nullptr;
1105     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1106 
1107     keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey);
1108 
1109     HcfObjDestroy(generator);
1110     HcfObjDestroy(keyPair);
1111 }
1112 
1113 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest850, TestSize.Level0)
1114 {
1115     HcfAsyKeyGenerator *generator = nullptr;
1116     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1117     EXPECT_EQ(res, HCF_SUCCESS);
1118     EXPECT_NE(generator, nullptr);
1119 
1120     HcfKeyPair *keyPair = nullptr;
1121     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1122 
1123     keyPair->priKey->clearMem(keyPair->priKey);
1124 
1125     HcfObjDestroy(generator);
1126     HcfObjDestroy(keyPair);
1127 }
1128 
1129 // correct case: use destroy function inclass(not HcfObjDestroy)
1130 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest900, TestSize.Level0)
1131 {
1132     HcfAsyKeyGenerator *generator = nullptr;
1133     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1134 
1135     HcfKeyPair *keyPair = nullptr;
1136     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1137 
1138     HcfPubKey *pubkey = keyPair->pubKey;
1139     HcfPriKey *prikey = keyPair->priKey;
1140 
1141     EXPECT_EQ(pubkey->base.getFormat((HcfKey *)prikey), nullptr);
1142     EXPECT_EQ(prikey->base.getFormat((HcfKey *)pubkey), nullptr);
1143 
1144     EXPECT_EQ(pubkey->base.getFormat(nullptr), nullptr);
1145     EXPECT_EQ(prikey->base.getFormat(nullptr), nullptr);
1146 
1147     EXPECT_EQ(pubkey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1148     EXPECT_EQ(prikey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
1149 
1150     EXPECT_EQ(pubkey->base.getAlgorithm(nullptr), nullptr);
1151     EXPECT_EQ(prikey->base.getAlgorithm(nullptr), nullptr);
1152 
1153     prikey->base.base.destroy(nullptr);
1154     pubkey->base.base.destroy(nullptr);
1155     keyPair->base.destroy(nullptr);
1156 
1157     prikey->base.base.destroy((HcfObjectBase *)pubkey);
1158     pubkey->base.base.destroy((HcfObjectBase *)prikey);
1159     keyPair->base.destroy((HcfObjectBase *)prikey);
1160 
1161     HcfObjDestroy(keyPair);
1162     HcfObjDestroy(generator);
1163 }
1164 
1165 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest901, TestSize.Level0)
1166 {
1167     HcfAsyKeyGenerator *generator = nullptr;
1168     HcfResult res = HcfAsyKeyGeneratorCreate("RSA", &generator);
1169     EXPECT_NE(res, HCF_SUCCESS);
1170     EXPECT_EQ(generator, nullptr);
1171     HcfObjDestroy(generator);
1172 }
1173 
1174 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest902, TestSize.Level0)
1175 {
1176     HcfAsyKeyGenerator *generator = nullptr;
1177     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
1178     EXPECT_EQ(res, HCF_SUCCESS);
1179     EXPECT_NE(generator, nullptr);
1180 
1181     HcfKeyPair *keyPair = nullptr;
1182     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1183     EXPECT_EQ(res, HCF_SUCCESS);
1184     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
1185     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1186     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
1187     EXPECT_EQ(res, HCF_SUCCESS);
1188     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
1189     EXPECT_EQ(res, HCF_SUCCESS);
1190 
1191     HcfKeyPair *dupKeyPair = nullptr;
1192     res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
1193     EXPECT_EQ(res, HCF_SUCCESS);
1194 
1195     HcfPriKey *prikey = dupKeyPair->priKey;
1196     EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1197     EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
1198     EXPECT_NE(prikey->base.base.getClass(), nullptr);
1199     EXPECT_NE(prikey->base.base.destroy, nullptr);
1200     EXPECT_NE(prikey->clearMem, nullptr);
1201 
1202     HcfFree(pubKeyBlob.data);
1203     HcfFree(priKeyBlob.data);
1204     HcfObjDestroy(generator);
1205     HcfObjDestroy(keyPair);
1206     HcfObjDestroy(dupKeyPair);
1207 }
1208 
1209 // test RSA key pair get
1210 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest903, TestSize.Level0)
1211 {
1212     HcfAsyKeyGenerator *generator = nullptr;
1213     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
1214     EXPECT_EQ(res, HCF_SUCCESS);
1215     EXPECT_NE(generator, nullptr);
1216 
1217     HcfKeyPair *keyPair = nullptr;
1218     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1219     EXPECT_EQ(res, HCF_SUCCESS);
1220     EXPECT_NE(keyPair, nullptr);
1221     HcfPriKey *priKey = keyPair->priKey;
1222     HcfPubKey *pubKey = keyPair->pubKey;
1223 
1224     HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
1225     HcfBigInteger returnPriN = { .data = nullptr, .len = 0 };
1226     HcfBigInteger returnE = { .data = nullptr, .len = 0 };
1227     HcfBigInteger returnD = { .data = nullptr, .len = 0 };
1228     res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &returnPriN);
1229     EXPECT_EQ(res, HCF_SUCCESS);
1230     res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &returnD);
1231     EXPECT_EQ(res, HCF_SUCCESS);
1232     res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
1233     EXPECT_EQ(res, HCF_SUCCESS);
1234     res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
1235     EXPECT_EQ(res, HCF_SUCCESS);
1236 
1237     HcfFree(returnPubN.data);
1238     HcfFree(returnPriN.data);
1239     HcfFree(returnD.data);
1240     HcfFree(returnE.data);
1241     HcfObjDestroy(generator);
1242     HcfObjDestroy(keyPair);
1243 }
1244 
1245 // spi create
1246 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest001, TestSize.Level0)
1247 {
1248     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1249     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(nullptr, &spiObj);
1250 
1251     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1252     ASSERT_EQ(spiObj, nullptr);
1253 }
1254 
1255 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest002, TestSize.Level0)
1256 {
1257     HcfAsyKeyGenParams params = {
1258         .algo = HCF_ALG_RSA,
1259         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1260         .primes = 0,
1261     };
1262 
1263     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, nullptr);
1264 
1265     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1266 }
1267 
1268 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest003, TestSize.Level0)
1269 {
1270     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1271     HcfAsyKeyGenParams params = {
1272         .algo = HCF_ALG_RSA,
1273         .bits = OPENSSL_RSA_KEY_SIZE_ABNORMAL,
1274         .primes = 0,
1275     };
1276 
1277     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1278 
1279     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1280     ASSERT_EQ(spiObj, nullptr);
1281 }
1282 
1283 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest004, TestSize.Level0)
1284 {
1285     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1286     HcfAsyKeyGenParams params = {
1287         .algo = HCF_ALG_RSA,
1288         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1289         .primes = OPENSSL_RSA_PRIMES_ABNORMAL,
1290     };
1291 
1292     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1293 
1294     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1295     ASSERT_EQ(spiObj, nullptr);
1296 }
1297 
1298 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest005, TestSize.Level0)
1299 {
1300     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1301     HcfAsyKeyGenParams params = {
1302         .algo = HCF_ALG_RSA,
1303         .bits = OPENSSL_RSA_KEY_SIZE_4096,
1304         .primes = OPENSSL_RSA_PRIMES_ABNORMAL,
1305     };
1306 
1307     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1308 
1309     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1310     ASSERT_EQ(spiObj, nullptr);
1311 }
1312 
1313 // spi gen keyPair
1314 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest006, TestSize.Level0)
1315 {
1316     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1317     HcfAsyKeyGenParams params = {
1318         .algo = HCF_ALG_RSA,
1319         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1320         .primes = 0,
1321     };
1322 
1323     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1324 
1325     EXPECT_EQ(res, HCF_SUCCESS);
1326     EXPECT_NE(spiObj, nullptr);
1327 
1328     HcfKeyPair *keyPair = nullptr;
1329     res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
1330     EXPECT_EQ(res, HCF_INVALID_PARAMS);
1331     HcfObjDestroy(spiObj);
1332 }
1333 
1334 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest007, TestSize.Level0)
1335 {
1336     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1337     HcfAsyKeyGenParams params = {
1338         .algo = HCF_ALG_RSA,
1339         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1340         .primes = 0,
1341     };
1342 
1343     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1344 
1345     EXPECT_EQ(res, HCF_SUCCESS);
1346     EXPECT_NE(spiObj, nullptr);
1347 
1348     res = spiObj->engineGenerateKeyPair(nullptr, nullptr);
1349     EXPECT_EQ(res, HCF_INVALID_PARAMS);
1350     HcfObjDestroy(spiObj);
1351 }
1352 
1353 // spi destroy
1354 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest008, TestSize.Level0)
1355 {
1356     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1357     HcfAsyKeyGenParams params = {
1358         .algo = HCF_ALG_RSA,
1359         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1360         .primes = 0,
1361     };
1362 
1363     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1364 
1365     EXPECT_EQ(res, HCF_SUCCESS);
1366     EXPECT_NE(spiObj, nullptr);
1367 
1368     spiObj->base.destroy(nullptr);
1369     HcfObjDestroy(spiObj);
1370 }
1371 
1372 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest009, TestSize.Level0)
1373 {
1374     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1375     HcfAsyKeyGenParams params = {
1376         .algo = HCF_ALG_RSA,
1377         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1378         .primes = 0,
1379     };
1380 
1381     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1382 
1383     EXPECT_EQ(res, HCF_SUCCESS);
1384     EXPECT_NE(spiObj, nullptr);
1385 
1386     spiObj->base.destroy(&g_obj);
1387     HcfObjDestroy(spiObj);
1388 }
1389 
1390 // spi convert
1391 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest010, TestSize.Level0)
1392 {
1393     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1394     HcfAsyKeyGenParams params = {
1395         .algo = HCF_ALG_RSA,
1396         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1397         .primes = 0,
1398     };
1399 
1400     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1401 
1402     EXPECT_EQ(res, HCF_SUCCESS);
1403     EXPECT_NE(spiObj, nullptr);
1404 
1405     HcfKeyPair *keyPair = nullptr;
1406     res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj,
1407         nullptr, &g_rsaCorrectPubKeyBlob, nullptr, &keyPair);
1408     HcfObjDestroy(spiObj);
1409 }
1410 
1411 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest011, TestSize.Level0)
1412 {
1413     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1414     HcfAsyKeyGenParams params = {
1415         .algo = HCF_ALG_RSA,
1416         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1417         .primes = 0,
1418     };
1419 
1420     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1421 
1422     EXPECT_EQ(res, HCF_SUCCESS);
1423     EXPECT_NE(spiObj, nullptr);
1424 
1425     HcfKeyPair *keyPair = nullptr;
1426     res = spiObj->engineConvertKey(nullptr, nullptr, &g_rsaCorrectPubKeyBlob, nullptr, &keyPair);
1427     HcfObjDestroy(spiObj);
1428 }
1429 
1430 // spi destroy
1431 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest012, TestSize.Level0)
1432 {
1433     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1434     HcfAsyKeyGenParams params = {
1435         .algo = HCF_ALG_RSA,
1436         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1437         .primes = 0,
1438     };
1439 
1440     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1441 
1442     EXPECT_EQ(res, HCF_SUCCESS);
1443     EXPECT_NE(spiObj, nullptr);
1444 
1445     spiObj->base.destroy(nullptr);
1446     EXPECT_NE(spiObj, nullptr);
1447     HcfObjDestroy(spiObj);
1448 }
1449 
1450 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest013, TestSize.Level0)
1451 {
1452     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1453     HcfAsyKeyGenParams params = {
1454         .algo = HCF_ALG_RSA,
1455         .bits = OPENSSL_RSA_KEY_SIZE_2048,
1456         .primes = 0,
1457     };
1458 
1459     HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(&params, &spiObj);
1460 
1461     EXPECT_EQ(res, HCF_SUCCESS);
1462     EXPECT_NE(spiObj, nullptr);
1463 
1464     spiObj->base.destroy(&g_obj);
1465     EXPECT_NE(spiObj, nullptr);
1466     HcfObjDestroy(spiObj);
1467 }
1468 }
1469