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 "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 HcfObjDestroy(NULL);
349 }
350
351 // generateKeyPair correct case
352 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest500, TestSize.Level0)
353 {
354 HcfAsyKeyGenerator *generator = NULL;
355 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
356
357 HcfKeyPair *keyPair = NULL;
358 res = generator->generateKeyPair(generator, NULL, &keyPair);
359
360 EXPECT_EQ(res, HCF_SUCCESS);
361 EXPECT_NE(keyPair, nullptr);
362 EXPECT_NE(keyPair->priKey, nullptr);
363 EXPECT_NE(keyPair->pubKey, nullptr);
364 EXPECT_NE(keyPair->base.getClass(), nullptr);
365 EXPECT_NE(keyPair->base.destroy, nullptr);
366
367 HcfPubKey *pubkey = keyPair->pubKey;
368 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
369 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
370 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
371 EXPECT_NE(pubkey->base.base.destroy, nullptr);
372
373 HcfPriKey *prikey = keyPair->priKey;
374 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
375 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
376 EXPECT_NE(prikey->base.base.getClass(), nullptr);
377 EXPECT_NE(prikey->base.base.destroy, nullptr);
378 EXPECT_NE(prikey->clearMem, nullptr);
379
380 HcfObjDestroy(keyPair);
381 HcfObjDestroy(generator);
382 }
383
384 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest510, TestSize.Level0)
385 {
386 HcfAsyKeyGenerator *generator = NULL;
387 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
388
389 HcfKeyPair *keyPair = NULL;
390 res = generator->generateKeyPair(generator, NULL, &keyPair);
391
392 EXPECT_EQ(res, HCF_SUCCESS);
393 EXPECT_NE(keyPair, nullptr);
394 EXPECT_NE(keyPair->priKey, nullptr);
395 EXPECT_NE(keyPair->pubKey, nullptr);
396 EXPECT_NE(keyPair->base.getClass(), nullptr);
397 EXPECT_NE(keyPair->base.destroy, nullptr);
398
399 HcfPubKey *pubkey = keyPair->pubKey;
400 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
401 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
402 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
403 EXPECT_NE(pubkey->base.base.destroy, nullptr);
404
405 HcfPriKey *prikey = keyPair->priKey;
406 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
407 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
408 EXPECT_NE(prikey->base.base.getClass(), nullptr);
409 EXPECT_NE(prikey->base.base.destroy, nullptr);
410 EXPECT_NE(prikey->clearMem, nullptr);
411
412 HcfObjDestroy(keyPair);
413 HcfObjDestroy(generator);
414 }
415
416 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest511, TestSize.Level0)
417 {
418 HcfAsyKeyGenerator *generator = NULL;
419 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_3", &generator);
420
421 HcfKeyPair *keyPair = NULL;
422 res = generator->generateKeyPair(generator, NULL, &keyPair);
423
424 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
425 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
426 HcfPubKey *pubKey = keyPair->pubKey;
427 HcfPriKey *priKey = keyPair->priKey;
428
429 res = pubKey->base.getEncoded((HcfKey *)priKey, &pubKeyBlob);
430 EXPECT_NE(res, HCF_SUCCESS);
431 res = priKey->base.getEncoded((HcfKey *)pubKey, &priKeyBlob);
432 EXPECT_NE(res, HCF_SUCCESS);
433 HcfObjDestroy(keyPair);
434 HcfObjDestroy(generator);
435 HcfFree(pubKeyBlob.data);
436 HcfFree(priKeyBlob.data);
437 }
438
439 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0)
440 {
441 HcfAsyKeyGenerator *generator = NULL;
442 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
443
444 HcfKeyPair *keyPair = NULL;
445 res = generator->generateKeyPair(generator, NULL, &keyPair);
446
447 HcfPubKey *pubKey = keyPair->pubKey;
448 HcfPriKey *priKey = keyPair->priKey;
449
450 res = pubKey->base.getEncoded((HcfKey *)priKey, NULL);
451 EXPECT_NE(res, HCF_SUCCESS);
452 res = priKey->base.getEncoded((HcfKey *)pubKey, NULL);
453 EXPECT_NE(res, HCF_SUCCESS);
454 HcfObjDestroy(keyPair);
455 HcfObjDestroy(generator);
456 }
457
458 // generateKeyPair conrrect case: use getEncode encode pubkey and prikey
459 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize.Level0)
460 {
461 HcfAsyKeyGenerator *generator = NULL;
462 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
463 EXPECT_EQ(res, HCF_SUCCESS);
464 EXPECT_NE(generator, nullptr);
465
466 HcfKeyPair *keyPair = NULL;
467 res = generator->generateKeyPair(generator, NULL, &keyPair);
468 EXPECT_EQ(res, HCF_SUCCESS);
469 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
470 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
471 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
472 EXPECT_EQ(res, HCF_SUCCESS);
473 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
474 EXPECT_EQ(res, HCF_SUCCESS);
475
476 HcfKeyPair *dupKeyPair = NULL;
477 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
478 EXPECT_EQ(res, HCF_SUCCESS);
479 HcfPubKey *pubkey = dupKeyPair->pubKey;
480 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
481 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
482 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
483 EXPECT_NE(pubkey->base.base.destroy, nullptr);
484
485 HcfPriKey *prikey = dupKeyPair->priKey;
486 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
487 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
488 EXPECT_NE(prikey->base.base.getClass(), nullptr);
489 EXPECT_NE(prikey->base.base.destroy, nullptr);
490 EXPECT_NE(prikey->clearMem, nullptr);
491
492 HcfFree(pubKeyBlob.data);
493 HcfFree(priKeyBlob.data);
494 HcfObjDestroy(generator);
495 HcfObjDestroy(keyPair);
496 HcfObjDestroy(dupKeyPair);
497 }
498
499 // Test muliti getEncoded and convertKey
500 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest521, TestSize.Level0)
501 {
502 HcfAsyKeyGenerator *generator = NULL;
503 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
504 EXPECT_EQ(res, HCF_SUCCESS);
505 EXPECT_NE(generator, nullptr);
506
507 HcfKeyPair *keyPair = NULL;
508 res = generator->generateKeyPair(generator, NULL, &keyPair);
509 EXPECT_EQ(res, HCF_SUCCESS);
510 HcfBlob pubKeyBlob1 = {.data = NULL, .len = 0};
511 HcfBlob priKeyBlob1 = {.data = NULL, .len = 0};
512 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob1);
513 EXPECT_EQ(res, HCF_SUCCESS);
514 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob1);
515 EXPECT_EQ(res, HCF_SUCCESS);
516
517 HcfKeyPair *dupKeyPair1 = NULL;
518 res = generator->convertKey(generator, NULL, &pubKeyBlob1, &priKeyBlob1, &dupKeyPair1);
519 EXPECT_EQ(res, HCF_SUCCESS);
520
521 HcfKeyPair *dupKeyPair2 = NULL;
522 HcfBlob pubKeyBlob2 = {.data = NULL, .len = 0};
523 HcfBlob priKeyBlob2 = {.data = NULL, .len = 0};
524 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob2);
525 EXPECT_EQ(res, HCF_SUCCESS);
526 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob2);
527 EXPECT_EQ(res, HCF_SUCCESS);
528 res = generator->convertKey(generator, NULL, &pubKeyBlob2, &priKeyBlob2, &dupKeyPair2);
529 EXPECT_EQ(res, HCF_SUCCESS);
530
531 HcfFree(pubKeyBlob1.data);
532 HcfFree(priKeyBlob1.data);
533 HcfFree(pubKeyBlob2.data);
534 HcfFree(priKeyBlob2.data);
535 HcfObjDestroy(generator);
536 HcfObjDestroy(keyPair);
537 HcfObjDestroy(dupKeyPair1);
538 HcfObjDestroy(dupKeyPair2);
539 }
540
541 // generateKeyPair correct case: getEncode encode pubkey
542 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize.Level0)
543 {
544 HcfAsyKeyGenerator *generator = NULL;
545 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
546 EXPECT_EQ(res, HCF_SUCCESS);
547 EXPECT_NE(generator, nullptr);
548
549 HcfKeyPair *keyPair = NULL;
550 res = generator->generateKeyPair(generator, NULL, &keyPair);
551 EXPECT_EQ(res, HCF_SUCCESS);
552 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
553 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
554 EXPECT_EQ(res, HCF_SUCCESS);
555
556 HcfKeyPair *dupKeyPair = NULL;
557 res = generator->convertKey(generator, NULL, &pubKeyBlob, NULL, &dupKeyPair);
558 EXPECT_EQ(res, HCF_SUCCESS);
559 HcfPubKey *pubkey = dupKeyPair->pubKey;
560 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
561 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
562 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
563 EXPECT_NE(pubkey->base.base.destroy, nullptr);
564
565 HcfFree(pubKeyBlob.data);
566 HcfObjDestroy(generator);
567 HcfObjDestroy(keyPair);
568 HcfObjDestroy(dupKeyPair);
569 }
570
571 // generateKeyPair correct case: getEncode encode prikey
572 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize.Level0)
573 {
574 HcfAsyKeyGenerator *generator = NULL;
575 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
576 EXPECT_EQ(res, HCF_SUCCESS);
577 EXPECT_NE(generator, nullptr);
578
579 HcfKeyPair *keyPair = NULL;
580 res = generator->generateKeyPair(generator, NULL, &keyPair);
581 EXPECT_EQ(res, HCF_SUCCESS);
582 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
583 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
584 EXPECT_EQ(res, HCF_SUCCESS);
585
586 HcfKeyPair *dupKeyPair = NULL;
587 res = generator->convertKey(generator, NULL, NULL, &priKeyBlob, &dupKeyPair);
588 EXPECT_EQ(res, HCF_SUCCESS);
589
590 HcfPriKey *prikey = dupKeyPair->priKey;
591 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
592 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
593 EXPECT_NE(prikey->base.base.getClass(), nullptr);
594 EXPECT_NE(prikey->base.base.destroy, nullptr);
595 EXPECT_NE(prikey->clearMem, nullptr);
596
597 HcfFree(priKeyBlob.data);
598 HcfObjDestroy(generator);
599 HcfObjDestroy(keyPair);
600 HcfObjDestroy(dupKeyPair);
601 }
602
603 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize.Level0)
604 {
605 HcfAsyKeyGenerator *generator = NULL;
606 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
607 EXPECT_EQ(res, HCF_SUCCESS);
608 EXPECT_NE(generator, nullptr);
609
610 HcfKeyPair *keyPair = NULL;
611 res = generator->generateKeyPair(generator, NULL, &keyPair);
612 EXPECT_EQ(res, HCF_SUCCESS);
613 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
614 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
615 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
616 EXPECT_EQ(res, HCF_SUCCESS);
617 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
618 EXPECT_EQ(res, HCF_SUCCESS);
619
620 HcfKeyPair *dupKeyPair = NULL;
621 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
622 EXPECT_EQ(res, HCF_SUCCESS);
623 HcfPubKey *pubkey = dupKeyPair->pubKey;
624 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
625 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
626 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
627 EXPECT_NE(pubkey->base.base.destroy, nullptr);
628
629 HcfPriKey *prikey = dupKeyPair->priKey;
630 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
631 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
632 EXPECT_NE(prikey->base.base.getClass(), nullptr);
633 EXPECT_NE(prikey->base.base.destroy, nullptr);
634 EXPECT_NE(prikey->clearMem, nullptr);
635
636 HcfFree(pubKeyBlob.data);
637 HcfFree(priKeyBlob.data);
638 HcfObjDestroy(generator);
639 HcfObjDestroy(keyPair);
640 HcfObjDestroy(dupKeyPair);
641 }
642
643 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize.Level0)
644 {
645 HcfAsyKeyGenerator *generator = NULL;
646 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
647 EXPECT_EQ(res, HCF_SUCCESS);
648 EXPECT_NE(generator, nullptr);
649
650 HcfKeyPair *keyPair = NULL;
651 res = generator->generateKeyPair(generator, NULL, &keyPair);
652 EXPECT_EQ(res, HCF_SUCCESS);
653 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
654 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
655 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
656 EXPECT_EQ(res, HCF_SUCCESS);
657 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
658 EXPECT_EQ(res, HCF_SUCCESS);
659
660 HcfKeyPair *dupKeyPair = NULL;
661 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
662 EXPECT_EQ(res, HCF_SUCCESS);
663 HcfPubKey *pubkey = dupKeyPair->pubKey;
664 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
665 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
666 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
667 EXPECT_NE(pubkey->base.base.destroy, nullptr);
668
669 HcfPriKey *prikey = dupKeyPair->priKey;
670 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
671 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
672 EXPECT_NE(prikey->base.base.getClass(), nullptr);
673 EXPECT_NE(prikey->base.base.destroy, nullptr);
674 EXPECT_NE(prikey->clearMem, nullptr);
675
676 HcfFree(pubKeyBlob.data);
677 HcfFree(priKeyBlob.data);
678 HcfObjDestroy(generator);
679 HcfObjDestroy(keyPair);
680 HcfObjDestroy(dupKeyPair);
681 }
682
683 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize.Level0)
684 {
685 HcfAsyKeyGenerator *generator = NULL;
686 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
687 EXPECT_EQ(res, HCF_SUCCESS);
688 EXPECT_NE(generator, nullptr);
689
690 HcfKeyPair *keyPair = NULL;
691 res = generator->generateKeyPair(generator, NULL, &keyPair);
692 EXPECT_EQ(res, HCF_SUCCESS);
693 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
694 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
695 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
696 EXPECT_EQ(res, HCF_SUCCESS);
697 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
698 EXPECT_EQ(res, HCF_SUCCESS);
699
700 HcfKeyPair *dupKeyPair = NULL;
701 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
702 EXPECT_EQ(res, HCF_SUCCESS);
703 HcfPubKey *pubkey = dupKeyPair->pubKey;
704 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
705 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
706 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
707 EXPECT_NE(pubkey->base.base.destroy, nullptr);
708
709 HcfPriKey *prikey = dupKeyPair->priKey;
710 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
711 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
712 EXPECT_NE(prikey->base.base.getClass(), nullptr);
713 EXPECT_NE(prikey->base.base.destroy, nullptr);
714 EXPECT_NE(prikey->clearMem, nullptr);
715
716 HcfFree(pubKeyBlob.data);
717 HcfFree(priKeyBlob.data);
718 HcfObjDestroy(generator);
719 HcfObjDestroy(keyPair);
720 HcfObjDestroy(dupKeyPair);
721 }
722
723 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize.Level0)
724 {
725 HcfAsyKeyGenerator *generator = NULL;
726 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
727 EXPECT_EQ(res, HCF_SUCCESS);
728 EXPECT_NE(generator, nullptr);
729
730 HcfKeyPair *keyPair = NULL;
731 res = generator->generateKeyPair(generator, NULL, &keyPair);
732 EXPECT_EQ(res, HCF_SUCCESS);
733 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
734 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
735 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
736 EXPECT_EQ(res, HCF_SUCCESS);
737 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
738 EXPECT_EQ(res, HCF_SUCCESS);
739
740 HcfKeyPair *dupKeyPair = NULL;
741 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
742 EXPECT_EQ(res, HCF_SUCCESS);
743 HcfPubKey *pubkey = dupKeyPair->pubKey;
744 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
745 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
746 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
747 EXPECT_NE(pubkey->base.base.destroy, nullptr);
748
749 HcfPriKey *prikey = dupKeyPair->priKey;
750 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
751 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
752 EXPECT_NE(prikey->base.base.getClass(), nullptr);
753 EXPECT_NE(prikey->base.base.destroy, nullptr);
754 EXPECT_NE(prikey->clearMem, nullptr);
755
756 HcfFree(pubKeyBlob.data);
757 HcfFree(priKeyBlob.data);
758 HcfObjDestroy(generator);
759 HcfObjDestroy(keyPair);
760 HcfObjDestroy(dupKeyPair);
761 }
762
763 // generateKeyPair incorrect case: user wrong ECC class, ignore in this version
764 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest600, TestSize.Level0)
765 {
766 HcfAsyKeyGenerator *eccGenerator = NULL;
767 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
768 EXPECT_EQ(res, HCF_SUCCESS);
769 EXPECT_NE(eccGenerator, nullptr);
770
771 HcfAsyKeyGenerator *rsaGenerator = NULL;
772 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
773 EXPECT_EQ(res, HCF_SUCCESS);
774 EXPECT_NE(rsaGenerator, nullptr);
775
776 HcfKeyPair *keyPair = NULL;
777 res = rsaGenerator->generateKeyPair(eccGenerator, NULL, &keyPair);
778
779 HcfObjDestroy(keyPair);
780 HcfObjDestroy(eccGenerator);
781 HcfObjDestroy(rsaGenerator);
782 }
783
784 // generateKeyPair incorrect case: generator class is null
785 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest610, TestSize.Level0)
786 {
787 HcfAsyKeyGenerator *rsaGenerator = NULL;
788 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
789 EXPECT_EQ(res, HCF_SUCCESS);
790 EXPECT_NE(rsaGenerator, nullptr);
791
792 HcfKeyPair *keyPair = NULL;
793 res = rsaGenerator->generateKeyPair(NULL, NULL, &keyPair);
794 EXPECT_NE(res, HCF_SUCCESS);
795 EXPECT_EQ(keyPair, nullptr);
796
797 HcfObjDestroy(rsaGenerator);
798 }
799
800 // generateKeyPair incorrect case: keypair is null
801 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest620, TestSize.Level0)
802 {
803 HcfAsyKeyGenerator *rsaGenerator = NULL;
804 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
805 EXPECT_EQ(res, HCF_SUCCESS);
806 EXPECT_NE(rsaGenerator, nullptr);
807
808 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, NULL);
809 EXPECT_NE(res, HCF_SUCCESS);
810
811 HcfObjDestroy(rsaGenerator);
812 }
813
814 // convertKey correct case
815 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize.Level0)
816 {
817 HcfAsyKeyGenerator *generator = NULL;
818 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
819 EXPECT_EQ(res, HCF_SUCCESS);
820 EXPECT_NE(generator, nullptr);
821
822 HcfKeyPair *keyPair = NULL;
823 res = generator->generateKeyPair(generator, NULL, &keyPair);
824 EXPECT_EQ(res, HCF_SUCCESS);
825 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
826 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
827 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
828 EXPECT_EQ(res, HCF_SUCCESS);
829 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
830 EXPECT_EQ(res, HCF_SUCCESS);
831
832 HcfKeyPair *dupKeyPair = NULL;
833 res = generator->convertKey(generator, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
834 EXPECT_EQ(res, HCF_SUCCESS);
835 HcfPubKey *pubkey = dupKeyPair->pubKey;
836 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
837 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
838 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
839 EXPECT_NE(pubkey->base.base.destroy, nullptr);
840
841 HcfPriKey *prikey = dupKeyPair->priKey;
842 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
843 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
844 EXPECT_NE(prikey->base.base.getClass(), nullptr);
845 EXPECT_NE(prikey->base.base.destroy, nullptr);
846 EXPECT_NE(prikey->clearMem, nullptr);
847
848 HcfFree(pubKeyBlob.data);
849 HcfFree(priKeyBlob.data);
850 HcfObjDestroy(generator);
851 HcfObjDestroy(keyPair);
852 HcfObjDestroy(dupKeyPair);
853 }
854
855 // convertKey incorrect case: input ECC class
856 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest710, TestSize.Level0)
857 {
858 HcfAsyKeyGenerator *eccGenerator = NULL;
859 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
860 EXPECT_EQ(res, HCF_SUCCESS);
861 EXPECT_NE(eccGenerator, nullptr);
862
863 HcfAsyKeyGenerator *rsaGenerator = NULL;
864 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
865 EXPECT_EQ(res, HCF_SUCCESS);
866 EXPECT_NE(rsaGenerator, nullptr);
867
868 HcfKeyPair *dupKeyPair = NULL;
869 res = rsaGenerator->convertKey(eccGenerator, NULL, NULL, NULL, &dupKeyPair);
870 EXPECT_NE(res, HCF_SUCCESS);
871 EXPECT_EQ(dupKeyPair, nullptr);
872
873 HcfObjDestroy(eccGenerator);
874 HcfObjDestroy(rsaGenerator);
875 }
876
877
878 // convertKey incorrect case: input null generator
879 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest720, TestSize.Level0)
880 {
881 HcfAsyKeyGenerator *rsaGenerator = NULL;
882 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
883 EXPECT_EQ(res, HCF_SUCCESS);
884 EXPECT_NE(rsaGenerator, nullptr);
885
886 HcfKeyPair *keyPair = NULL;
887 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair);
888 EXPECT_EQ(res, HCF_SUCCESS);
889 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
890 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
891 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
892 EXPECT_EQ(res, HCF_SUCCESS);
893 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
894 EXPECT_EQ(res, HCF_SUCCESS);
895
896 HcfKeyPair *dupKeyPair = NULL;
897 res = rsaGenerator->convertKey(NULL, NULL, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
898 EXPECT_NE(res, HCF_SUCCESS);
899 EXPECT_EQ(dupKeyPair, nullptr);
900
901 HcfFree(pubKeyBlob.data);
902 HcfFree(priKeyBlob.data);
903 HcfObjDestroy(keyPair);
904 HcfObjDestroy(rsaGenerator);
905 }
906
907 // convertKey incorrect case: input null dupkeypair
908 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest730, TestSize.Level0)
909 {
910 HcfAsyKeyGenerator *rsaGenerator = NULL;
911 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
912 EXPECT_EQ(res, HCF_SUCCESS);
913 EXPECT_NE(rsaGenerator, nullptr);
914
915 HcfKeyPair *keyPair = NULL;
916 res = rsaGenerator->generateKeyPair(rsaGenerator, NULL, &keyPair);
917 EXPECT_EQ(res, HCF_SUCCESS);
918 HcfBlob pubKeyBlob = {.data = NULL, .len = 0};
919 HcfBlob priKeyBlob = {.data = NULL, .len = 0};
920 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
921 EXPECT_EQ(res, HCF_SUCCESS);
922 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
923 EXPECT_EQ(res, HCF_SUCCESS);
924
925 HcfKeyPair *dupKeyPair = NULL;
926 res = rsaGenerator->convertKey(rsaGenerator, NULL, &pubKeyBlob, &priKeyBlob, NULL);
927 EXPECT_NE(res, HCF_SUCCESS);
928 EXPECT_EQ(dupKeyPair, nullptr);
929
930 HcfFree(pubKeyBlob.data);
931 HcfFree(priKeyBlob.data);
932 HcfObjDestroy(keyPair);
933 HcfObjDestroy(rsaGenerator);
934 }
935
936 // Incorrect case: use wrong bits or primes
937 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest800, TestSize.Level0)
938 {
939 HcfAsyKeyGenerator *generator = NULL;
940 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1111", &generator);
941 EXPECT_NE(res, HCF_SUCCESS);
942 EXPECT_EQ(generator, nullptr);
943 HcfObjDestroy(generator);
944 }
945
946 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest810, TestSize.Level0)
947 {
948 HcfAsyKeyGenerator *generator = NULL;
949 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
950 EXPECT_NE(res, HCF_SUCCESS);
951 EXPECT_EQ(generator, nullptr);
952 HcfObjDestroy(generator);
953 }
954
955 // 测试异常释放
956 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest820, TestSize.Level0)
957 {
958 HcfAsyKeyGenerator *generator = NULL;
959 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
960 EXPECT_NE(res, HCF_SUCCESS);
961 EXPECT_EQ(generator, nullptr);
962 HcfObjDestroy(generator);
963 }
964
965 // prikey clear mem
966 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest830, TestSize.Level0)
967 {
968 HcfAsyKeyGenerator *generator = NULL;
969 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
970 HcfKeyPair *keyPair = NULL;
971 res = generator->generateKeyPair(generator, NULL, &keyPair);
972 EXPECT_EQ(res, HCF_SUCCESS);
973 EXPECT_NE(keyPair, nullptr);
974
975 keyPair->priKey->clearMem(NULL);
976
977 HcfObjDestroy(generator);
978 HcfObjDestroy(keyPair);
979 }
980
981 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest840, TestSize.Level0)
982 {
983 HcfAsyKeyGenerator *generator = NULL;
984 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
985 HcfKeyPair *keyPair = NULL;
986 res = generator->generateKeyPair(generator, NULL, &keyPair);
987 EXPECT_EQ(res, HCF_SUCCESS);
988 EXPECT_NE(keyPair, nullptr);
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 EXPECT_EQ(res, HCF_SUCCESS);
1003 EXPECT_NE(keyPair, nullptr);
1004
1005 keyPair->priKey->clearMem(keyPair->priKey);
1006
1007 HcfObjDestroy(generator);
1008 HcfObjDestroy(keyPair);
1009 }
1010
1011 // correct case: use destroy function inclass(not HcfObjDestroy)
1012 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest900, TestSize.Level0)
1013 {
1014 HcfAsyKeyGenerator *generator = NULL;
1015 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1016
1017 HcfKeyPair *keyPair = NULL;
1018 res = generator->generateKeyPair(generator, NULL, &keyPair);
1019
1020 HcfPubKey *pubkey = keyPair->pubKey;
1021 HcfPriKey *prikey = keyPair->priKey;
1022
1023 EXPECT_EQ(pubkey->base.getFormat((HcfKey *)prikey), nullptr);
1024 EXPECT_EQ(prikey->base.getFormat((HcfKey *)pubkey), nullptr);
1025
1026 EXPECT_EQ(pubkey->base.getFormat(NULL), nullptr);
1027 EXPECT_EQ(prikey->base.getFormat(NULL), nullptr);
1028
1029 EXPECT_EQ(pubkey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1030 EXPECT_EQ(prikey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
1031
1032 EXPECT_EQ(pubkey->base.getAlgorithm(NULL), nullptr);
1033 EXPECT_EQ(prikey->base.getAlgorithm(NULL), nullptr);
1034
1035 prikey->base.base.destroy(NULL);
1036 pubkey->base.base.destroy(NULL);
1037 keyPair->base.destroy(NULL);
1038
1039 prikey->base.base.destroy((HcfObjectBase *)pubkey);
1040 pubkey->base.base.destroy((HcfObjectBase *)prikey);
1041 keyPair->base.destroy((HcfObjectBase *)prikey);
1042
1043 HcfObjDestroy(keyPair);
1044 HcfObjDestroy(generator);
1045 }
1046 }
1047