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
19 #include "asy_key_generator.h"
20 #include "blob.h"
21 #include "memory.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 class CryptoRsaAsyKeyGeneratorTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase()35 void CryptoRsaAsyKeyGeneratorTest::SetUpTestCase() {}
TearDownTestCase()36 void CryptoRsaAsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()37 void CryptoRsaAsyKeyGeneratorTest::SetUp() {}
TearDown()38 void CryptoRsaAsyKeyGeneratorTest::TearDown() {}
39
40 // HcfAsyKeyGeneratorCreate correct case: no primes
41 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest100, TestSize.Level0)
42 {
43 HcfAsyKeyGenerator *generator = NULL;
44 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
45 EXPECT_EQ(res, HCF_SUCCESS);
46 EXPECT_NE(generator, nullptr);
47 EXPECT_NE(generator->base.getClass(), nullptr);
48 EXPECT_NE(generator->base.destroy, nullptr);
49 EXPECT_NE(generator->generateKeyPair, nullptr);
50 EXPECT_NE(generator->getAlgoName, nullptr);
51 HcfObjDestroy(generator);
52 }
53
54 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest110, TestSize.Level0)
55 {
56 HcfAsyKeyGenerator *generator = NULL;
57 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
58 EXPECT_EQ(res, HCF_SUCCESS);
59 EXPECT_NE(generator, nullptr);
60 EXPECT_NE(generator->base.getClass(), nullptr);
61 EXPECT_NE(generator->base.destroy, nullptr);
62 EXPECT_NE(generator->generateKeyPair, nullptr);
63 EXPECT_NE(generator->getAlgoName, nullptr);
64 HcfObjDestroy(generator);
65 }
66
67 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest120, TestSize.Level0)
68 {
69 HcfAsyKeyGenerator *generator = NULL;
70 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
71 EXPECT_EQ(res, HCF_SUCCESS);
72 EXPECT_NE(generator, nullptr);
73 EXPECT_NE(generator->base.getClass(), nullptr);
74 EXPECT_NE(generator->base.destroy, nullptr);
75 EXPECT_NE(generator->generateKeyPair, nullptr);
76 EXPECT_NE(generator->getAlgoName, nullptr);
77 HcfObjDestroy(generator);
78 }
79
80
81 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest130, TestSize.Level0)
82 {
83 HcfAsyKeyGenerator *generator = NULL;
84 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
85 EXPECT_EQ(res, HCF_SUCCESS);
86 EXPECT_NE(generator, nullptr);
87 EXPECT_NE(generator->base.getClass(), nullptr);
88 EXPECT_NE(generator->base.destroy, nullptr);
89 EXPECT_NE(generator->generateKeyPair, nullptr);
90 EXPECT_NE(generator->getAlgoName, nullptr);
91 HcfObjDestroy(generator);
92 }
93
94 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest140, TestSize.Level0)
95 {
96 HcfAsyKeyGenerator *generator = NULL;
97 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
98 EXPECT_EQ(res, HCF_SUCCESS);
99 EXPECT_NE(generator, nullptr);
100 EXPECT_NE(generator->base.getClass(), nullptr);
101 EXPECT_NE(generator->base.destroy, nullptr);
102 EXPECT_NE(generator->generateKeyPair, nullptr);
103 EXPECT_NE(generator->getAlgoName, nullptr);
104 HcfObjDestroy(generator);
105 }
106
107 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest150, TestSize.Level0)
108 {
109 HcfAsyKeyGenerator *generator = NULL;
110 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
111 EXPECT_EQ(res, HCF_SUCCESS);
112 EXPECT_NE(generator, nullptr);
113 EXPECT_NE(generator->base.getClass(), nullptr);
114 EXPECT_NE(generator->base.destroy, nullptr);
115 EXPECT_NE(generator->generateKeyPair, nullptr);
116 EXPECT_NE(generator->getAlgoName, nullptr);
117 HcfObjDestroy(generator);
118 }
119
120 // HcfAsyKeyGeneratorCreate correct case: with primes
121 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest200, TestSize.Level0)
122 {
123 HcfAsyKeyGenerator *generator = NULL;
124 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_2", &generator);
125 EXPECT_EQ(res, HCF_SUCCESS);
126 EXPECT_NE(generator, nullptr);
127 EXPECT_NE(generator->base.getClass(), nullptr);
128 EXPECT_NE(generator->base.destroy, nullptr);
129 EXPECT_NE(generator->generateKeyPair, nullptr);
130 EXPECT_NE(generator->getAlgoName, nullptr);
131 HcfObjDestroy(generator);
132 }
133
134 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest210, TestSize.Level0)
135 {
136 HcfAsyKeyGenerator *generator = NULL;
137 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator);
138 EXPECT_EQ(res, HCF_SUCCESS);
139 EXPECT_NE(generator, nullptr);
140 EXPECT_NE(generator->base.getClass(), nullptr);
141 EXPECT_NE(generator->base.destroy, nullptr);
142 EXPECT_NE(generator->generateKeyPair, nullptr);
143 EXPECT_NE(generator->getAlgoName, nullptr);
144 HcfObjDestroy(generator);
145 }
146
147 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest220, TestSize.Level0)
148 {
149 HcfAsyKeyGenerator *generator = NULL;
150 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
151 EXPECT_EQ(res, HCF_SUCCESS);
152 EXPECT_NE(generator, nullptr);
153 EXPECT_NE(generator->base.getClass(), nullptr);
154 EXPECT_NE(generator->base.destroy, nullptr);
155 EXPECT_NE(generator->generateKeyPair, nullptr);
156 EXPECT_NE(generator->getAlgoName, nullptr);
157 HcfObjDestroy(generator);
158 }
159
160 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest230, TestSize.Level0)
161 {
162 HcfAsyKeyGenerator *generator = NULL;
163 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
164 EXPECT_EQ(res, HCF_SUCCESS);
165 EXPECT_NE(generator, nullptr);
166 EXPECT_NE(generator->base.getClass(), nullptr);
167 EXPECT_NE(generator->base.destroy, nullptr);
168 EXPECT_NE(generator->generateKeyPair, nullptr);
169 EXPECT_NE(generator->getAlgoName, nullptr);
170 HcfObjDestroy(generator);
171 }
172
173 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest240, TestSize.Level0)
174 {
175 HcfAsyKeyGenerator *generator = NULL;
176 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
177 EXPECT_EQ(res, HCF_SUCCESS);
178 EXPECT_NE(generator, nullptr);
179 EXPECT_NE(generator->base.getClass(), nullptr);
180 EXPECT_NE(generator->base.destroy, nullptr);
181 EXPECT_NE(generator->generateKeyPair, nullptr);
182 EXPECT_NE(generator->getAlgoName, nullptr);
183 HcfObjDestroy(generator);
184 }
185
186 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest250, TestSize.Level0)
187 {
188 HcfAsyKeyGenerator *generator = NULL;
189 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator);
190 EXPECT_EQ(res, HCF_SUCCESS);
191 EXPECT_NE(generator, nullptr);
192 EXPECT_NE(generator->base.getClass(), nullptr);
193 EXPECT_NE(generator->base.destroy, nullptr);
194 EXPECT_NE(generator->generateKeyPair, nullptr);
195 EXPECT_NE(generator->getAlgoName, nullptr);
196 HcfObjDestroy(generator);
197 }
198
199 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest260, TestSize.Level0)
200 {
201 HcfAsyKeyGenerator *generator = NULL;
202 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
203 EXPECT_EQ(res, HCF_SUCCESS);
204 EXPECT_NE(generator, nullptr);
205 EXPECT_NE(generator->base.getClass(), nullptr);
206 EXPECT_NE(generator->base.destroy, nullptr);
207 EXPECT_NE(generator->generateKeyPair, nullptr);
208 EXPECT_NE(generator->getAlgoName, nullptr);
209 HcfObjDestroy(generator);
210 }
211
212 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest270, TestSize.Level0)
213 {
214 HcfAsyKeyGenerator *generator = NULL;
215 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_4", &generator);
216 EXPECT_EQ(res, HCF_SUCCESS);
217 EXPECT_NE(generator, nullptr);
218 EXPECT_NE(generator->base.getClass(), nullptr);
219 EXPECT_NE(generator->base.destroy, nullptr);
220 EXPECT_NE(generator->generateKeyPair, nullptr);
221 EXPECT_NE(generator->getAlgoName, nullptr);
222 HcfObjDestroy(generator);
223 }
224
225 // HcfAsyKeyGeneratorCreate Incorrect case : algname is null
226 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest300, TestSize.Level0)
227 {
228 HcfAsyKeyGenerator *generator = NULL;
229 HcfResult res = HcfAsyKeyGeneratorCreate(NULL, &generator);
230 EXPECT_NE(res, HCF_SUCCESS);
231 EXPECT_EQ(generator, nullptr);
232 HcfObjDestroy(generator);
233 }
234
235 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest301, TestSize.Level0)
236 {
237 HcfAsyKeyGenerator *generator = NULL;
238 HcfResult res = HcfAsyKeyGeneratorCreate("", &generator);
239 EXPECT_NE(res, HCF_SUCCESS);
240 }
241
242 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest310, TestSize.Level0)
243 {
244 HcfAsyKeyGenerator *generator = NULL;
245 HcfResult res = HcfAsyKeyGeneratorCreate("111111111111111111111111111111111111111111111111111111111111111111111111"
246 "111111111111111111111111111111111111111111111111111111111111111111111", &generator);
247 EXPECT_NE(res, HCF_SUCCESS);
248 EXPECT_EQ(generator, nullptr);
249 HcfObjDestroy(generator);
250 }
251
252 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest320, TestSize.Level0)
253 {
254 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", NULL);
255 EXPECT_NE(res, HCF_SUCCESS);
256 }
257
258 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest330, TestSize.Level0)
259 {
260 HcfAsyKeyGenerator *generator = NULL;
261 HcfResult res = HcfAsyKeyGeneratorCreate("RSA12315", &generator);
262 EXPECT_NE(res, HCF_SUCCESS);
263 EXPECT_EQ(generator, nullptr);
264 HcfObjDestroy(generator);
265 }
266
267 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest340, TestSize.Level0)
268 {
269 HcfAsyKeyGenerator *generator = NULL;
270 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_777", &generator);
271 EXPECT_NE(res, HCF_SUCCESS);
272 EXPECT_EQ(generator, nullptr);
273 HcfObjDestroy(generator);
274 }
275
276 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest350, TestSize.Level0)
277 {
278 HcfAsyKeyGenerator *generator = NULL;
279 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_3", &generator);
280 EXPECT_NE(res, HCF_SUCCESS);
281 EXPECT_EQ(generator, nullptr);
282 HcfObjDestroy(generator);
283 }
284
285 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest360, TestSize.Level0)
286 {
287 HcfAsyKeyGenerator *generator = NULL;
288 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_3", &generator);
289 EXPECT_NE(res, HCF_SUCCESS);
290 EXPECT_EQ(generator, nullptr);
291 HcfObjDestroy(generator);
292 }
293
294 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest370, TestSize.Level0)
295 {
296 HcfAsyKeyGenerator *generator = NULL;
297 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_4", &generator);
298 EXPECT_NE(res, HCF_SUCCESS);
299 EXPECT_EQ(generator, nullptr);
300 HcfObjDestroy(generator);
301 }
302
303 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest380, TestSize.Level0)
304 {
305 HcfAsyKeyGenerator *generator = NULL;
306 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_4", &generator);
307 EXPECT_NE(res, HCF_SUCCESS);
308 EXPECT_EQ(generator, nullptr);
309 HcfObjDestroy(generator);
310 }
311
312 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest381, TestSize.Level0)
313 {
314 HcfAsyKeyGenerator *generator = NULL;
315 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
316 EXPECT_EQ(res, HCF_SUCCESS);
317 EXPECT_NE(generator, nullptr);
318 HcfObjDestroy(generator);
319 }
320
321 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest390, TestSize.Level0)
322 {
323 HcfAsyKeyGenerator *generator = NULL;
324 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_5", &generator);
325 EXPECT_NE(res, HCF_SUCCESS);
326 EXPECT_EQ(generator, nullptr);
327 HcfObjDestroy(generator);
328 }
329
330 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest391, TestSize.Level0)
331 {
332 HcfAsyKeyGenerator *generator = NULL;
333 HcfResult res = HcfAsyKeyGeneratorCreate("RSA8192|PRIMES_5", &generator);
334 EXPECT_EQ(res, HCF_SUCCESS);
335 EXPECT_NE(generator, nullptr);
336 HcfObjDestroy(generator);
337 }
338
339 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest400, TestSize.Level0)
340 {
341 HcfAsyKeyGenerator *generator = NULL;
342 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
343 EXPECT_EQ(res, HCF_SUCCESS);
344 EXPECT_NE(generator, nullptr);
345 HcfObjDestroy(generator);
346 generator = NULL;
347 HcfObjDestroy(generator);
348 }
349
350 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest410, TestSize.Level0)
351 {
352 HcfObjDestroy(NULL);
353 }
354
355 // generateKeyPair correct case
356 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest500, TestSize.Level0)
357 {
358 HcfAsyKeyGenerator *generator = NULL;
359 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
360
361 HcfKeyPair *keyPair = NULL;
362 res = generator->generateKeyPair(generator, NULL, &keyPair);
363
364 EXPECT_EQ(res, HCF_SUCCESS);
365 EXPECT_NE(keyPair, nullptr);
366 EXPECT_NE(keyPair->priKey, nullptr);
367 EXPECT_NE(keyPair->pubKey, nullptr);
368 EXPECT_NE(keyPair->base.getClass(), nullptr);
369 EXPECT_NE(keyPair->base.destroy, nullptr);
370
371 HcfPubKey *pubkey = keyPair->pubKey;
372 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
373 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
374 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
375 EXPECT_NE(pubkey->base.base.destroy, nullptr);
376
377 HcfPriKey *prikey = keyPair->priKey;
378 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
379 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
380 EXPECT_NE(prikey->base.base.getClass(), nullptr);
381 EXPECT_NE(prikey->base.base.destroy, nullptr);
382 EXPECT_NE(prikey->clearMem, nullptr);
383
384 HcfObjDestroy(keyPair);
385 HcfObjDestroy(generator);
386 }
387
388 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest510, TestSize.Level0)
389 {
390 HcfAsyKeyGenerator *generator = NULL;
391 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
392
393 HcfKeyPair *keyPair = NULL;
394 res = generator->generateKeyPair(generator, NULL, &keyPair);
395
396 EXPECT_EQ(res, HCF_SUCCESS);
397 EXPECT_NE(keyPair, nullptr);
398 EXPECT_NE(keyPair->priKey, nullptr);
399 EXPECT_NE(keyPair->pubKey, nullptr);
400 EXPECT_NE(keyPair->base.getClass(), nullptr);
401 EXPECT_NE(keyPair->base.destroy, nullptr);
402
403 HcfPubKey *pubkey = keyPair->pubKey;
404 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
405 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
406 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
407 EXPECT_NE(pubkey->base.base.destroy, nullptr);
408
409 HcfPriKey *prikey = keyPair->priKey;
410 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
411 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
412 EXPECT_NE(prikey->base.base.getClass(), nullptr);
413 EXPECT_NE(prikey->base.base.destroy, nullptr);
414 EXPECT_NE(prikey->clearMem, nullptr);
415
416 HcfObjDestroy(keyPair);
417 HcfObjDestroy(generator);
418 }
419
420 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest511, TestSize.Level0)
421 {
422 HcfAsyKeyGenerator *generator = NULL;
423 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator);
424
425 HcfKeyPair *keyPair = NULL;
426 res = generator->generateKeyPair(generator, NULL, &keyPair);
427
428 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
429 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
430 HcfPubKey *pubKey = keyPair->pubKey;
431 HcfPriKey *priKey = keyPair->priKey;
432
433 res = pubKey->base.getEncoded((HcfKey *)priKey, &pubKeyBlob);
434 EXPECT_NE(res, HCF_SUCCESS);
435 res = priKey->base.getEncoded((HcfKey *)pubKey, &priKeyBlob);
436 EXPECT_NE(res, HCF_SUCCESS);
437 HcfObjDestroy(keyPair);
438 HcfObjDestroy(generator);
439 HcfFree(pubKeyBlob.data);
440 HcfFree(priKeyBlob.data);
441 }
442
443 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0)
444 {
445 HcfAsyKeyGenerator *generator = NULL;
446 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
447
448 HcfKeyPair *keyPair = NULL;
449 res = generator->generateKeyPair(generator, NULL, &keyPair);
450
451 HcfPubKey *pubKey = keyPair->pubKey;
452 HcfPriKey *priKey = keyPair->priKey;
453
454 res = pubKey->base.getEncoded((HcfKey *)priKey, NULL);
455 EXPECT_NE(res, HCF_SUCCESS);
456 res = priKey->base.getEncoded((HcfKey *)pubKey, NULL);
457 EXPECT_NE(res, HCF_SUCCESS);
458 HcfObjDestroy(keyPair);
459 HcfObjDestroy(generator);
460 }
461
462 // generateKeyPair conrrect case: use getEncode encode pubkey and prikey
463 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize.Level0)
464 {
465 HcfAsyKeyGenerator *generator = NULL;
466 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
467 EXPECT_EQ(res, HCF_SUCCESS);
468 EXPECT_NE(generator, nullptr);
469
470 HcfKeyPair *keyPair = NULL;
471 res = generator->generateKeyPair(generator, NULL, &keyPair);
472 EXPECT_EQ(res, HCF_SUCCESS);
473 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
474 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
475 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
476 EXPECT_EQ(res, HCF_SUCCESS);
477 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
478 EXPECT_EQ(res, HCF_SUCCESS);
479
480 HcfKeyPair *dupKeyPair = NULL;
481 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
482 EXPECT_EQ(res, HCF_SUCCESS);
483 HcfPubKey *pubkey = dupKeyPair->pubKey;
484 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
485 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
486 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
487 EXPECT_NE(pubkey->base.base.destroy, nullptr);
488
489 HcfPriKey *prikey = dupKeyPair->priKey;
490 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
491 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
492 EXPECT_NE(prikey->base.base.getClass(), nullptr);
493 EXPECT_NE(prikey->base.base.destroy, nullptr);
494 EXPECT_NE(prikey->clearMem, nullptr);
495
496 HcfFree(pubKeyBlob.data);
497 HcfFree(priKeyBlob.data);
498 HcfObjDestroy(generator);
499 HcfObjDestroy(keyPair);
500 HcfObjDestroy(dupKeyPair);
501 }
502
503 // Test muliti getEncoded and convertKey
504 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest521, TestSize.Level0)
505 {
506 HcfAsyKeyGenerator *generator = NULL;
507 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
508 EXPECT_EQ(res, HCF_SUCCESS);
509 EXPECT_NE(generator, nullptr);
510
511 HcfKeyPair *keyPair = NULL;
512 res = generator->generateKeyPair(generator, NULL, &keyPair);
513 EXPECT_EQ(res, HCF_SUCCESS);
514 HcfBlob pubKeyBlob1 = {.data = NULL, .len = 0};
515 HcfBlob priKeyBlob1 = {.data = NULL, .len = 0};
516 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob1);
517 EXPECT_EQ(res, HCF_SUCCESS);
518 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob1);
519 EXPECT_EQ(res, HCF_SUCCESS);
520
521 HcfKeyPair *dupKeyPair1 = NULL;
522 res = generator->convertKey(generator, NULL, &pubKeyBlob1, &priKeyBlob1, &dupKeyPair1);
523 EXPECT_EQ(res, HCF_SUCCESS);
524
525 HcfKeyPair *dupKeyPair2 = NULL;
526 HcfBlob pubKeyBlob2 = {.data = NULL, .len = 0};
527 HcfBlob priKeyBlob2 = {.data = NULL, .len = 0};
528 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob2);
529 EXPECT_EQ(res, HCF_SUCCESS);
530 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob2);
531 EXPECT_EQ(res, HCF_SUCCESS);
532 res = generator->convertKey(generator, NULL, &pubKeyBlob2, &priKeyBlob2, &dupKeyPair2);
533 EXPECT_EQ(res, HCF_SUCCESS);
534
535 HcfFree(pubKeyBlob1.data);
536 HcfFree(priKeyBlob1.data);
537 HcfFree(pubKeyBlob2.data);
538 HcfFree(priKeyBlob2.data);
539 HcfObjDestroy(generator);
540 HcfObjDestroy(keyPair);
541 HcfObjDestroy(dupKeyPair1);
542 HcfObjDestroy(dupKeyPair2);
543 }
544
545 // generateKeyPair correct case: getEncode encode pubkey
546 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize.Level0)
547 {
548 HcfAsyKeyGenerator *generator = NULL;
549 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
550 EXPECT_EQ(res, HCF_SUCCESS);
551 EXPECT_NE(generator, nullptr);
552
553 HcfKeyPair *keyPair = NULL;
554 res = generator->generateKeyPair(generator, NULL, &keyPair);
555 EXPECT_EQ(res, HCF_SUCCESS);
556 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
557 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
558 EXPECT_EQ(res, HCF_SUCCESS);
559
560 HcfKeyPair *dupKeyPair = NULL;
561 res = generator->convertKey(generator, NULL, &pubKeyBlob, NULL, &dupKeyPair);
562 EXPECT_EQ(res, HCF_SUCCESS);
563 HcfPubKey *pubkey = dupKeyPair->pubKey;
564 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
565 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
566 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
567 EXPECT_NE(pubkey->base.base.destroy, nullptr);
568
569 HcfFree(pubKeyBlob.data);
570 HcfObjDestroy(generator);
571 HcfObjDestroy(keyPair);
572 HcfObjDestroy(dupKeyPair);
573 }
574
575 // generateKeyPair correct case: getEncode encode prikey
576 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize.Level0)
577 {
578 HcfAsyKeyGenerator *generator = NULL;
579 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
580 EXPECT_EQ(res, HCF_SUCCESS);
581 EXPECT_NE(generator, nullptr);
582
583 HcfKeyPair *keyPair = NULL;
584 res = generator->generateKeyPair(generator, NULL, &keyPair);
585 EXPECT_EQ(res, HCF_SUCCESS);
586 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
587 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
588 EXPECT_EQ(res, HCF_SUCCESS);
589
590 HcfKeyPair *dupKeyPair = NULL;
591 res = generator->convertKey(generator, NULL, NULL, &priKeyBlob, &dupKeyPair);
592 EXPECT_EQ(res, HCF_SUCCESS);
593
594 HcfPriKey *prikey = dupKeyPair->priKey;
595 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
596 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
597 EXPECT_NE(prikey->base.base.getClass(), nullptr);
598 EXPECT_NE(prikey->base.base.destroy, nullptr);
599 EXPECT_NE(prikey->clearMem, nullptr);
600
601 HcfFree(priKeyBlob.data);
602 HcfObjDestroy(generator);
603 HcfObjDestroy(keyPair);
604 HcfObjDestroy(dupKeyPair);
605 }
606
607 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize.Level0)
608 {
609 HcfAsyKeyGenerator *generator = NULL;
610 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
611 EXPECT_EQ(res, HCF_SUCCESS);
612 EXPECT_NE(generator, nullptr);
613
614 HcfKeyPair *keyPair = NULL;
615 res = generator->generateKeyPair(generator, NULL, &keyPair);
616 EXPECT_EQ(res, HCF_SUCCESS);
617 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
618 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
619 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
620 EXPECT_EQ(res, HCF_SUCCESS);
621 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
622 EXPECT_EQ(res, HCF_SUCCESS);
623
624 HcfKeyPair *dupKeyPair = NULL;
625 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
626 EXPECT_EQ(res, HCF_SUCCESS);
627 HcfPubKey *pubkey = dupKeyPair->pubKey;
628 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
629 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
630 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
631 EXPECT_NE(pubkey->base.base.destroy, nullptr);
632
633 HcfPriKey *prikey = dupKeyPair->priKey;
634 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
635 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
636 EXPECT_NE(prikey->base.base.getClass(), nullptr);
637 EXPECT_NE(prikey->base.base.destroy, nullptr);
638 EXPECT_NE(prikey->clearMem, nullptr);
639
640 HcfFree(pubKeyBlob.data);
641 HcfFree(priKeyBlob.data);
642 HcfObjDestroy(generator);
643 HcfObjDestroy(keyPair);
644 HcfObjDestroy(dupKeyPair);
645 }
646
647 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize.Level0)
648 {
649 HcfAsyKeyGenerator *generator = NULL;
650 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
651 EXPECT_EQ(res, HCF_SUCCESS);
652 EXPECT_NE(generator, nullptr);
653
654 HcfKeyPair *keyPair = NULL;
655 res = generator->generateKeyPair(generator, NULL, &keyPair);
656 EXPECT_EQ(res, HCF_SUCCESS);
657 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
658 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
659 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
660 EXPECT_EQ(res, HCF_SUCCESS);
661 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
662 EXPECT_EQ(res, HCF_SUCCESS);
663
664 HcfKeyPair *dupKeyPair = NULL;
665 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
666 EXPECT_EQ(res, HCF_SUCCESS);
667 HcfPubKey *pubkey = dupKeyPair->pubKey;
668 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
669 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
670 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
671 EXPECT_NE(pubkey->base.base.destroy, nullptr);
672
673 HcfPriKey *prikey = dupKeyPair->priKey;
674 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
675 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
676 EXPECT_NE(prikey->base.base.getClass(), nullptr);
677 EXPECT_NE(prikey->base.base.destroy, nullptr);
678 EXPECT_NE(prikey->clearMem, nullptr);
679
680 HcfFree(pubKeyBlob.data);
681 HcfFree(priKeyBlob.data);
682 HcfObjDestroy(generator);
683 HcfObjDestroy(keyPair);
684 HcfObjDestroy(dupKeyPair);
685 }
686
687 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize.Level0)
688 {
689 HcfAsyKeyGenerator *generator = NULL;
690 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
691 EXPECT_EQ(res, HCF_SUCCESS);
692 EXPECT_NE(generator, nullptr);
693
694 HcfKeyPair *keyPair = NULL;
695 res = generator->generateKeyPair(generator, NULL, &keyPair);
696 EXPECT_EQ(res, HCF_SUCCESS);
697 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
698 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
699 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
700 EXPECT_EQ(res, HCF_SUCCESS);
701 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
702 EXPECT_EQ(res, HCF_SUCCESS);
703
704 HcfKeyPair *dupKeyPair = NULL;
705 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
706 EXPECT_EQ(res, HCF_SUCCESS);
707 HcfPubKey *pubkey = dupKeyPair->pubKey;
708 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
709 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
710 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
711 EXPECT_NE(pubkey->base.base.destroy, nullptr);
712
713 HcfPriKey *prikey = dupKeyPair->priKey;
714 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
715 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
716 EXPECT_NE(prikey->base.base.getClass(), nullptr);
717 EXPECT_NE(prikey->base.base.destroy, nullptr);
718 EXPECT_NE(prikey->clearMem, nullptr);
719
720 HcfFree(pubKeyBlob.data);
721 HcfFree(priKeyBlob.data);
722 HcfObjDestroy(generator);
723 HcfObjDestroy(keyPair);
724 HcfObjDestroy(dupKeyPair);
725 }
726
727 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize.Level0)
728 {
729 HcfAsyKeyGenerator *generator = NULL;
730 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
731 EXPECT_EQ(res, HCF_SUCCESS);
732 EXPECT_NE(generator, nullptr);
733
734 HcfKeyPair *keyPair = NULL;
735 res = generator->generateKeyPair(generator, NULL, &keyPair);
736 EXPECT_EQ(res, HCF_SUCCESS);
737 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
738 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
739 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
740 EXPECT_EQ(res, HCF_SUCCESS);
741 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
742 EXPECT_EQ(res, HCF_SUCCESS);
743
744 HcfKeyPair *dupKeyPair = NULL;
745 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
746 EXPECT_EQ(res, HCF_SUCCESS);
747 HcfPubKey *pubkey = dupKeyPair->pubKey;
748 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
749 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
750 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
751 EXPECT_NE(pubkey->base.base.destroy, nullptr);
752
753 HcfPriKey *prikey = dupKeyPair->priKey;
754 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
755 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
756 EXPECT_NE(prikey->base.base.getClass(), nullptr);
757 EXPECT_NE(prikey->base.base.destroy, nullptr);
758 EXPECT_NE(prikey->clearMem, nullptr);
759
760 HcfFree(pubKeyBlob.data);
761 HcfFree(priKeyBlob.data);
762 HcfObjDestroy(generator);
763 HcfObjDestroy(keyPair);
764 HcfObjDestroy(dupKeyPair);
765 }
766
767 // generateKeyPair incorrect case: user wrong ECC class, ignore in this version
768 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest600, TestSize.Level0)
769 {
770 HcfAsyKeyGenerator *eccGenerator = NULL;
771 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
772 EXPECT_EQ(res, HCF_SUCCESS);
773 EXPECT_NE(eccGenerator, nullptr);
774
775 HcfAsyKeyGenerator *rsaGenerator = NULL;
776 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
777 EXPECT_EQ(res, HCF_SUCCESS);
778 EXPECT_NE(rsaGenerator, nullptr);
779
780 HcfKeyPair *keyPair = NULL;
781 res = rsaGenerator->generateKeyPair(eccGenerator, NULL, &keyPair);
782
783 HcfObjDestroy(keyPair);
784 HcfObjDestroy(eccGenerator);
785 HcfObjDestroy(rsaGenerator);
786 }
787
788 // generateKeyPair incorrect case: generator class is null
789 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest610, TestSize.Level0)
790 {
791 HcfAsyKeyGenerator *rsaGenerator = NULL;
792 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
793 EXPECT_EQ(res, HCF_SUCCESS);
794 EXPECT_NE(rsaGenerator, nullptr);
795
796 HcfKeyPair *keyPair = NULL;
797 res = rsaGenerator->generateKeyPair(NULL, NULL, &keyPair);
798 EXPECT_NE(res, HCF_SUCCESS);
799 EXPECT_EQ(keyPair, nullptr);
800
801 HcfObjDestroy(rsaGenerator);
802 }
803
804 // generateKeyPair incorrect case: keypair is null
805 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest620, TestSize.Level0)
806 {
807 HcfAsyKeyGenerator *rsaGenerator = NULL;
808 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
809 EXPECT_EQ(res, HCF_SUCCESS);
810 EXPECT_NE(rsaGenerator, nullptr);
811
812 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, NULL);
813 EXPECT_NE(res, HCF_SUCCESS);
814
815 HcfObjDestroy(rsaGenerator);
816 }
817
818 // convertKey correct case
819 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize.Level0)
820 {
821 HcfAsyKeyGenerator *generator = NULL;
822 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
823 EXPECT_EQ(res, HCF_SUCCESS);
824 EXPECT_NE(generator, nullptr);
825
826 HcfKeyPair *keyPair = NULL;
827 res = generator->generateKeyPair(generator, NULL, &keyPair);
828 EXPECT_EQ(res, HCF_SUCCESS);
829 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
830 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
831 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
832 EXPECT_EQ(res, HCF_SUCCESS);
833 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
834 EXPECT_EQ(res, HCF_SUCCESS);
835
836 HcfKeyPair *dupKeyPair = NULL;
837 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
838 EXPECT_EQ(res, HCF_SUCCESS);
839 HcfPubKey *pubkey = dupKeyPair->pubKey;
840 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
841 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
842 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
843 EXPECT_NE(pubkey->base.base.destroy, nullptr);
844
845 HcfPriKey *prikey = dupKeyPair->priKey;
846 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
847 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
848 EXPECT_NE(prikey->base.base.getClass(), nullptr);
849 EXPECT_NE(prikey->base.base.destroy, nullptr);
850 EXPECT_NE(prikey->clearMem, nullptr);
851
852 HcfFree(pubKeyBlob.data);
853 HcfFree(priKeyBlob.data);
854 HcfObjDestroy(generator);
855 HcfObjDestroy(keyPair);
856 HcfObjDestroy(dupKeyPair);
857 }
858
859 // convertKey incorrect case: input ECC class
860 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest710, TestSize.Level0)
861 {
862 HcfAsyKeyGenerator *eccGenerator = NULL;
863 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
864 EXPECT_EQ(res, HCF_SUCCESS);
865 EXPECT_NE(eccGenerator, nullptr);
866
867 HcfAsyKeyGenerator *rsaGenerator = NULL;
868 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
869 EXPECT_EQ(res, HCF_SUCCESS);
870 EXPECT_NE(rsaGenerator, nullptr);
871
872 HcfKeyPair *dupKeyPair = NULL;
873 res = rsaGenerator->convertKey(eccGenerator, NULL, NULL, NULL, &dupKeyPair);
874 EXPECT_NE(res, HCF_SUCCESS);
875 EXPECT_EQ(dupKeyPair, nullptr);
876
877 HcfObjDestroy(eccGenerator);
878 HcfObjDestroy(rsaGenerator);
879 }
880
881
882 // convertKey incorrect case: input null generator
883 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest720, TestSize.Level0)
884 {
885 HcfAsyKeyGenerator *rsaGenerator = NULL;
886 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
887 EXPECT_EQ(res, HCF_SUCCESS);
888 EXPECT_NE(rsaGenerator, nullptr);
889
890 HcfKeyPair *keyPair = NULL;
891 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair);
892 EXPECT_EQ(res, HCF_SUCCESS);
893 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
894 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
895 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
896 EXPECT_EQ(res, HCF_SUCCESS);
897 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
898 EXPECT_EQ(res, HCF_SUCCESS);
899
900 HcfKeyPair *dupKeyPair = NULL;
901 res = rsaGenerator->convertKey(NULL, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
902 EXPECT_NE(res, HCF_SUCCESS);
903 EXPECT_EQ(dupKeyPair, nullptr);
904
905 HcfFree(pubKeyBlob.data);
906 HcfFree(priKeyBlob.data);
907 HcfObjDestroy(keyPair);
908 HcfObjDestroy(rsaGenerator);
909 }
910
911 // convertKey incorrect case: input null dupkeypair
912 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest730, TestSize.Level0)
913 {
914 HcfAsyKeyGenerator *rsaGenerator = NULL;
915 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
916 EXPECT_EQ(res, HCF_SUCCESS);
917 EXPECT_NE(rsaGenerator, nullptr);
918
919 HcfKeyPair *keyPair = NULL;
920 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair);
921 EXPECT_EQ(res, HCF_SUCCESS);
922 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
923 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
924 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
925 EXPECT_EQ(res, HCF_SUCCESS);
926 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
927 EXPECT_EQ(res, HCF_SUCCESS);
928
929 HcfKeyPair *dupKeyPair = NULL;
930 res = rsaGenerator->convertKey(rsaGenerator, NULL, &pubKeyBlob, &priKeyBlob, NULL);
931 EXPECT_NE(res, HCF_SUCCESS);
932 EXPECT_EQ(dupKeyPair, nullptr);
933
934 HcfFree(pubKeyBlob.data);
935 HcfFree(priKeyBlob.data);
936 HcfObjDestroy(keyPair);
937 HcfObjDestroy(rsaGenerator);
938 }
939
940 // Incorrect case: use wrong bits or primes
941 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest800, TestSize.Level0)
942 {
943 HcfAsyKeyGenerator *generator = NULL;
944 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1111", &generator);
945 EXPECT_NE(res, HCF_SUCCESS);
946 EXPECT_EQ(generator, nullptr);
947 HcfObjDestroy(generator);
948 }
949
950 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest810, TestSize.Level0)
951 {
952 HcfAsyKeyGenerator *generator = NULL;
953 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
954 EXPECT_NE(res, HCF_SUCCESS);
955 EXPECT_EQ(generator, nullptr);
956 HcfObjDestroy(generator);
957 }
958
959 // 测试异常释放
960 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest820, TestSize.Level0)
961 {
962 HcfAsyKeyGenerator *generator = NULL;
963 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
964 EXPECT_NE(res, HCF_SUCCESS);
965 EXPECT_EQ(generator, nullptr);
966 HcfObjDestroy(generator);
967 }
968
969 // prikey clear mem
970 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest830, TestSize.Level0)
971 {
972 HcfAsyKeyGenerator *generator = NULL;
973 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
974 HcfKeyPair *keyPair = NULL;
975 res = generator->generateKeyPair(generator, NULL, &keyPair);
976
977 keyPair->priKey->clearMem(NULL);
978
979 HcfObjDestroy(generator);
980 HcfObjDestroy(keyPair);
981 }
982
983 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest840, TestSize.Level0)
984 {
985 HcfAsyKeyGenerator *generator = NULL;
986 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
987 HcfKeyPair *keyPair = NULL;
988 res = generator->generateKeyPair(generator, NULL, &keyPair);
989
990 keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey);
991
992 HcfObjDestroy(generator);
993 HcfObjDestroy(keyPair);
994 }
995
996 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest850, TestSize.Level0)
997 {
998 HcfAsyKeyGenerator *generator = NULL;
999 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1000 HcfKeyPair *keyPair = NULL;
1001 res = generator->generateKeyPair(generator, NULL, &keyPair);
1002
1003 keyPair->priKey->clearMem(keyPair->priKey);
1004
1005 HcfObjDestroy(generator);
1006 HcfObjDestroy(keyPair);
1007 }
1008
1009 // correct case: use destroy function inclass(not HcfObjDestroy)
1010 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest900, TestSize.Level0)
1011 {
1012 HcfAsyKeyGenerator *generator = NULL;
1013 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1014
1015 HcfKeyPair *keyPair = NULL;
1016 res = generator->generateKeyPair(generator, NULL, &keyPair);
1017
1018 HcfPubKey *pubkey = keyPair->pubKey;
1019 HcfPriKey *prikey = keyPair->priKey;
1020
1021 EXPECT_EQ(pubkey->base.getFormat((HcfKey *)prikey), nullptr);
1022 EXPECT_EQ(prikey->base.getFormat((HcfKey *)pubkey), nullptr);
1023
1024 EXPECT_EQ(pubkey->base.getFormat(NULL), nullptr);
1025 EXPECT_EQ(prikey->base.getFormat(NULL), nullptr);
1026
1027 EXPECT_EQ(pubkey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1028 EXPECT_EQ(prikey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
1029
1030 EXPECT_EQ(pubkey->base.getAlgorithm(NULL), nullptr);
1031 EXPECT_EQ(prikey->base.getAlgorithm(NULL), nullptr);
1032
1033 prikey->base.base.destroy(NULL);
1034 pubkey->base.base.destroy(NULL);
1035 keyPair->base.destroy(NULL);
1036
1037 prikey->base.base.destroy((HcfObjectBase *)pubkey);
1038 pubkey->base.base.destroy((HcfObjectBase *)prikey);
1039 keyPair->base.destroy((HcfObjectBase *)prikey);
1040
1041 HcfObjDestroy(keyPair);
1042 HcfObjDestroy(generator);
1043 }
1044 }
1045