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 }
474
475 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0)
476 {
477 HcfAsyKeyGenerator *generator = nullptr;
478 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
479
480 HcfKeyPair *keyPair = nullptr;
481 res = generator->generateKeyPair(generator, nullptr, &keyPair);
482
483 HcfPubKey *pubKey = keyPair->pubKey;
484 HcfPriKey *priKey = keyPair->priKey;
485
486 res = pubKey->base.getEncoded((HcfKey *)priKey, nullptr);
487 EXPECT_NE(res, HCF_SUCCESS);
488 res = priKey->base.getEncoded((HcfKey *)pubKey, nullptr);
489 EXPECT_NE(res, HCF_SUCCESS);
490 HcfObjDestroy(keyPair);
491 HcfObjDestroy(generator);
492 }
493
494 // generateKeyPair conrrect case: use getEncode encode pubkey and prikey
495 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest520, TestSize.Level0)
496 {
497 HcfAsyKeyGenerator *generator = nullptr;
498 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
499 EXPECT_EQ(res, HCF_SUCCESS);
500 EXPECT_NE(generator, nullptr);
501
502 HcfKeyPair *keyPair = nullptr;
503 res = generator->generateKeyPair(generator, nullptr, &keyPair);
504 EXPECT_EQ(res, HCF_SUCCESS);
505 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
506 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
507 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
508 EXPECT_EQ(res, HCF_SUCCESS);
509 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
510 EXPECT_EQ(res, HCF_SUCCESS);
511
512 HcfKeyPair *dupKeyPair = nullptr;
513 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
514 EXPECT_EQ(res, HCF_SUCCESS);
515 HcfPubKey *pubkey = dupKeyPair->pubKey;
516 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
517 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
518 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
519 EXPECT_NE(pubkey->base.base.destroy, nullptr);
520
521 HcfPriKey *prikey = dupKeyPair->priKey;
522 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
523 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
524 EXPECT_NE(prikey->base.base.getClass(), nullptr);
525 EXPECT_NE(prikey->base.base.destroy, nullptr);
526 EXPECT_NE(prikey->clearMem, nullptr);
527
528 HcfFree(pubKeyBlob.data);
529 HcfFree(priKeyBlob.data);
530 HcfObjDestroy(generator);
531 HcfObjDestroy(keyPair);
532 HcfObjDestroy(dupKeyPair);
533 }
534
535 // Test muliti getEncoded and convertKey
536 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest521, TestSize.Level0)
537 {
538 HcfAsyKeyGenerator *generator = nullptr;
539 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
540 EXPECT_EQ(res, HCF_SUCCESS);
541 EXPECT_NE(generator, nullptr);
542
543 HcfKeyPair *keyPair = nullptr;
544 res = generator->generateKeyPair(generator, nullptr, &keyPair);
545 EXPECT_EQ(res, HCF_SUCCESS);
546 HcfBlob pubKeyBlob1 = {.data = nullptr, .len = 0};
547 HcfBlob priKeyBlob1 = {.data = nullptr, .len = 0};
548 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob1);
549 EXPECT_EQ(res, HCF_SUCCESS);
550 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob1);
551 EXPECT_EQ(res, HCF_SUCCESS);
552
553 HcfKeyPair *dupKeyPair1 = nullptr;
554 res = generator->convertKey(generator, nullptr, &pubKeyBlob1, &priKeyBlob1, &dupKeyPair1);
555 EXPECT_EQ(res, HCF_SUCCESS);
556
557 HcfKeyPair *dupKeyPair2 = nullptr;
558 HcfBlob pubKeyBlob2 = {.data = nullptr, .len = 0};
559 HcfBlob priKeyBlob2 = {.data = nullptr, .len = 0};
560 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob2);
561 EXPECT_EQ(res, HCF_SUCCESS);
562 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob2);
563 EXPECT_EQ(res, HCF_SUCCESS);
564 res = generator->convertKey(generator, nullptr, &pubKeyBlob2, &priKeyBlob2, &dupKeyPair2);
565 EXPECT_EQ(res, HCF_SUCCESS);
566
567 HcfFree(pubKeyBlob1.data);
568 HcfFree(priKeyBlob1.data);
569 HcfFree(pubKeyBlob2.data);
570 HcfFree(priKeyBlob2.data);
571 HcfObjDestroy(generator);
572 HcfObjDestroy(keyPair);
573 HcfObjDestroy(dupKeyPair1);
574 HcfObjDestroy(dupKeyPair2);
575 }
576
577 // generateKeyPair correct case: getEncode encode pubkey
578 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest530, TestSize.Level0)
579 {
580 HcfAsyKeyGenerator *generator = nullptr;
581 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_3", &generator);
582 EXPECT_EQ(res, HCF_SUCCESS);
583 EXPECT_NE(generator, nullptr);
584
585 HcfKeyPair *keyPair = nullptr;
586 res = generator->generateKeyPair(generator, nullptr, &keyPair);
587 EXPECT_EQ(res, HCF_SUCCESS);
588 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
589 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
590 EXPECT_EQ(res, HCF_SUCCESS);
591
592 HcfKeyPair *dupKeyPair = nullptr;
593 res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &dupKeyPair);
594 EXPECT_EQ(res, HCF_SUCCESS);
595 HcfPubKey *pubkey = dupKeyPair->pubKey;
596 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
597 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
598 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
599 EXPECT_NE(pubkey->base.base.destroy, nullptr);
600
601 HcfFree(pubKeyBlob.data);
602 HcfObjDestroy(generator);
603 HcfObjDestroy(keyPair);
604 HcfObjDestroy(dupKeyPair);
605 }
606
607 // generateKeyPair correct case: getEncode encode prikey
608 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest540, TestSize.Level0)
609 {
610 HcfAsyKeyGenerator *generator = nullptr;
611 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
612 EXPECT_EQ(res, HCF_SUCCESS);
613 EXPECT_NE(generator, nullptr);
614
615 HcfKeyPair *keyPair = nullptr;
616 res = generator->generateKeyPair(generator, nullptr, &keyPair);
617 EXPECT_EQ(res, HCF_SUCCESS);
618 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
619 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
620 EXPECT_EQ(res, HCF_SUCCESS);
621
622 HcfKeyPair *dupKeyPair = nullptr;
623 res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
624 EXPECT_EQ(res, HCF_SUCCESS);
625
626 HcfPriKey *prikey = dupKeyPair->priKey;
627 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
628 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
629 EXPECT_NE(prikey->base.base.getClass(), nullptr);
630 EXPECT_NE(prikey->base.base.destroy, nullptr);
631 EXPECT_NE(prikey->clearMem, nullptr);
632
633 HcfFree(priKeyBlob.data);
634 HcfObjDestroy(generator);
635 HcfObjDestroy(keyPair);
636 HcfObjDestroy(dupKeyPair);
637 }
638
639 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest550, TestSize.Level0)
640 {
641 HcfAsyKeyGenerator *generator = nullptr;
642 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072", &generator);
643 EXPECT_EQ(res, HCF_SUCCESS);
644 EXPECT_NE(generator, nullptr);
645
646 HcfKeyPair *keyPair = nullptr;
647 res = generator->generateKeyPair(generator, nullptr, &keyPair);
648 EXPECT_EQ(res, HCF_SUCCESS);
649 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
650 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
651 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
652 EXPECT_EQ(res, HCF_SUCCESS);
653 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
654 EXPECT_EQ(res, HCF_SUCCESS);
655
656 HcfKeyPair *dupKeyPair = nullptr;
657 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
658 EXPECT_EQ(res, HCF_SUCCESS);
659 HcfPubKey *pubkey = dupKeyPair->pubKey;
660 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
661 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
662 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
663 EXPECT_NE(pubkey->base.base.destroy, nullptr);
664
665 HcfPriKey *prikey = dupKeyPair->priKey;
666 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
667 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
668 EXPECT_NE(prikey->base.base.getClass(), nullptr);
669 EXPECT_NE(prikey->base.base.destroy, nullptr);
670 EXPECT_NE(prikey->clearMem, nullptr);
671
672 HcfFree(pubKeyBlob.data);
673 HcfFree(priKeyBlob.data);
674 HcfObjDestroy(generator);
675 HcfObjDestroy(keyPair);
676 HcfObjDestroy(dupKeyPair);
677 }
678
679 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest560, TestSize.Level0)
680 {
681 HcfAsyKeyGenerator *generator = nullptr;
682 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096", &generator);
683 EXPECT_EQ(res, HCF_SUCCESS);
684 EXPECT_NE(generator, nullptr);
685
686 HcfKeyPair *keyPair = nullptr;
687 res = generator->generateKeyPair(generator, nullptr, &keyPair);
688 EXPECT_EQ(res, HCF_SUCCESS);
689 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
690 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
691 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
692 EXPECT_EQ(res, HCF_SUCCESS);
693 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
694 EXPECT_EQ(res, HCF_SUCCESS);
695
696 HcfKeyPair *dupKeyPair = nullptr;
697 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
698 EXPECT_EQ(res, HCF_SUCCESS);
699 HcfPubKey *pubkey = dupKeyPair->pubKey;
700 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
701 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
702 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
703 EXPECT_NE(pubkey->base.base.destroy, nullptr);
704
705 HcfPriKey *prikey = dupKeyPair->priKey;
706 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
707 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
708 EXPECT_NE(prikey->base.base.getClass(), nullptr);
709 EXPECT_NE(prikey->base.base.destroy, nullptr);
710 EXPECT_NE(prikey->clearMem, nullptr);
711
712 HcfFree(pubKeyBlob.data);
713 HcfFree(priKeyBlob.data);
714 HcfObjDestroy(generator);
715 HcfObjDestroy(keyPair);
716 HcfObjDestroy(dupKeyPair);
717 }
718
719 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest570, TestSize.Level0)
720 {
721 HcfAsyKeyGenerator *generator = nullptr;
722 HcfResult res = HcfAsyKeyGeneratorCreate("RSA512", &generator);
723 EXPECT_EQ(res, HCF_SUCCESS);
724 EXPECT_NE(generator, nullptr);
725
726 HcfKeyPair *keyPair = nullptr;
727 res = generator->generateKeyPair(generator, nullptr, &keyPair);
728 EXPECT_EQ(res, HCF_SUCCESS);
729 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
730 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
731 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
732 EXPECT_EQ(res, HCF_SUCCESS);
733 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
734 EXPECT_EQ(res, HCF_SUCCESS);
735
736 HcfKeyPair *dupKeyPair = nullptr;
737 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
738 EXPECT_EQ(res, HCF_SUCCESS);
739 HcfPubKey *pubkey = dupKeyPair->pubKey;
740 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
741 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
742 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
743 EXPECT_NE(pubkey->base.base.destroy, nullptr);
744
745 HcfPriKey *prikey = dupKeyPair->priKey;
746 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
747 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
748 EXPECT_NE(prikey->base.base.getClass(), nullptr);
749 EXPECT_NE(prikey->base.base.destroy, nullptr);
750 EXPECT_NE(prikey->clearMem, nullptr);
751
752 HcfFree(pubKeyBlob.data);
753 HcfFree(priKeyBlob.data);
754 HcfObjDestroy(generator);
755 HcfObjDestroy(keyPair);
756 HcfObjDestroy(dupKeyPair);
757 }
758
759 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest580, TestSize.Level0)
760 {
761 HcfAsyKeyGenerator *generator = nullptr;
762 HcfResult res = HcfAsyKeyGeneratorCreate("RSA768", &generator);
763 EXPECT_EQ(res, HCF_SUCCESS);
764 EXPECT_NE(generator, nullptr);
765
766 HcfKeyPair *keyPair = nullptr;
767 res = generator->generateKeyPair(generator, nullptr, &keyPair);
768 EXPECT_EQ(res, HCF_SUCCESS);
769 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
770 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
771 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
772 EXPECT_EQ(res, HCF_SUCCESS);
773 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
774 EXPECT_EQ(res, HCF_SUCCESS);
775
776 HcfKeyPair *dupKeyPair = nullptr;
777 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
778 EXPECT_EQ(res, HCF_SUCCESS);
779 HcfPubKey *pubkey = dupKeyPair->pubKey;
780 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
781 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
782 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
783 EXPECT_NE(pubkey->base.base.destroy, nullptr);
784
785 HcfPriKey *prikey = dupKeyPair->priKey;
786 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
787 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
788 EXPECT_NE(prikey->base.base.getClass(), nullptr);
789 EXPECT_NE(prikey->base.base.destroy, nullptr);
790 EXPECT_NE(prikey->clearMem, nullptr);
791
792 HcfFree(pubKeyBlob.data);
793 HcfFree(priKeyBlob.data);
794 HcfObjDestroy(generator);
795 HcfObjDestroy(keyPair);
796 HcfObjDestroy(dupKeyPair);
797 }
798
799 // generateKeyPair incorrect case: user wrong ECC class, ignore in this version
800 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest600, TestSize.Level0)
801 {
802 HcfAsyKeyGenerator *eccGenerator = nullptr;
803 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
804 EXPECT_EQ(res, HCF_SUCCESS);
805 EXPECT_NE(eccGenerator, nullptr);
806
807 HcfAsyKeyGenerator *rsaGenerator = nullptr;
808 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
809 EXPECT_EQ(res, HCF_SUCCESS);
810 EXPECT_NE(rsaGenerator, nullptr);
811
812 HcfKeyPair *keyPair = nullptr;
813 // innerkit调用，在framework层中，指针无法判断eccGenerator调用的self，所以keypair实际不为空。
814 // 会调到ecc的generatekeyPair，生成ecc的keypair对象（class为ecckeypair）
815 // 对js调用，能否防范？
816 res = rsaGenerator->generateKeyPair(eccGenerator, nullptr, &keyPair);
817 // 经验证，keypair不为空,且为ecc的keypair
818 EXPECT_NE(keyPair, nullptr);
819 EXPECT_STREQ("OPENSSL.ECC.KEY_PAIR", keyPair->base.getClass());
820
821 HcfObjDestroy(keyPair);
822 HcfObjDestroy(eccGenerator);
823 HcfObjDestroy(rsaGenerator);
824 }
825
826 // generateKeyPair incorrect case: generator class is null
827 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest610, TestSize.Level0)
828 {
829 HcfAsyKeyGenerator *rsaGenerator = nullptr;
830 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
831 EXPECT_EQ(res, HCF_SUCCESS);
832 EXPECT_NE(rsaGenerator, nullptr);
833
834 HcfKeyPair *keyPair = nullptr;
835 res = rsaGenerator->generateKeyPair(nullptr, nullptr, &keyPair);
836 EXPECT_NE(res, HCF_SUCCESS);
837 EXPECT_EQ(keyPair, nullptr);
838
839 HcfObjDestroy(rsaGenerator);
840 }
841
842 // generateKeyPair incorrect case: keypair is null
843 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest620, TestSize.Level0)
844 {
845 HcfAsyKeyGenerator *rsaGenerator = nullptr;
846 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
847 EXPECT_EQ(res, HCF_SUCCESS);
848 EXPECT_NE(rsaGenerator, nullptr);
849
850 res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, nullptr);
851 EXPECT_NE(res, HCF_SUCCESS);
852
853 HcfObjDestroy(rsaGenerator);
854 }
855
856 // convertKey correct case
857 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest700, TestSize.Level0)
858 {
859 HcfAsyKeyGenerator *generator = nullptr;
860 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
861 EXPECT_EQ(res, HCF_SUCCESS);
862 EXPECT_NE(generator, nullptr);
863
864 HcfKeyPair *keyPair = nullptr;
865 res = generator->generateKeyPair(generator, nullptr, &keyPair);
866 EXPECT_EQ(res, HCF_SUCCESS);
867 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
868 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
869 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
870 EXPECT_EQ(res, HCF_SUCCESS);
871 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
872 EXPECT_EQ(res, HCF_SUCCESS);
873
874 HcfKeyPair *dupKeyPair = nullptr;
875 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
876 EXPECT_EQ(res, HCF_SUCCESS);
877 HcfPubKey *pubkey = dupKeyPair->pubKey;
878 EXPECT_NE(pubkey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
879 EXPECT_NE(pubkey->base.getFormat((HcfKey *)pubkey), nullptr);
880 EXPECT_NE(pubkey->base.base.getClass(), nullptr);
881 EXPECT_NE(pubkey->base.base.destroy, nullptr);
882
883 HcfPriKey *prikey = dupKeyPair->priKey;
884 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
885 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
886 EXPECT_NE(prikey->base.base.getClass(), nullptr);
887 EXPECT_NE(prikey->base.base.destroy, nullptr);
888 EXPECT_NE(prikey->clearMem, nullptr);
889
890 HcfFree(pubKeyBlob.data);
891 HcfFree(priKeyBlob.data);
892 HcfObjDestroy(generator);
893 HcfObjDestroy(keyPair);
894 HcfObjDestroy(dupKeyPair);
895 }
896
897 // convertKey incorrect case: input ECC class
898 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest710, TestSize.Level0)
899 {
900 HcfAsyKeyGenerator *eccGenerator = nullptr;
901 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &eccGenerator);
902 EXPECT_EQ(res, HCF_SUCCESS);
903 EXPECT_NE(eccGenerator, nullptr);
904
905 HcfAsyKeyGenerator *rsaGenerator = nullptr;
906 res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
907 EXPECT_EQ(res, HCF_SUCCESS);
908 EXPECT_NE(rsaGenerator, nullptr);
909
910 HcfKeyPair *dupKeyPair = nullptr;
911 res = rsaGenerator->convertKey(eccGenerator, nullptr, nullptr, nullptr, &dupKeyPair);
912 EXPECT_NE(res, HCF_SUCCESS);
913 EXPECT_EQ(dupKeyPair, nullptr);
914
915 HcfObjDestroy(eccGenerator);
916 HcfObjDestroy(rsaGenerator);
917 }
918
919
920 // convertKey incorrect case: input null generator
921 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest720, TestSize.Level0)
922 {
923 HcfAsyKeyGenerator *rsaGenerator = nullptr;
924 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
925 EXPECT_EQ(res, HCF_SUCCESS);
926 EXPECT_NE(rsaGenerator, nullptr);
927
928 HcfKeyPair *keyPair = nullptr;
929 res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair);
930 EXPECT_EQ(res, HCF_SUCCESS);
931 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
932 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
933 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
934 EXPECT_EQ(res, HCF_SUCCESS);
935 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
936 EXPECT_EQ(res, HCF_SUCCESS);
937
938 HcfKeyPair *dupKeyPair = nullptr;
939 res = rsaGenerator->convertKey(nullptr, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
940 EXPECT_NE(res, HCF_SUCCESS);
941 EXPECT_EQ(dupKeyPair, nullptr);
942
943 HcfFree(pubKeyBlob.data);
944 HcfFree(priKeyBlob.data);
945 HcfObjDestroy(keyPair);
946 HcfObjDestroy(rsaGenerator);
947 }
948
949 // convertKey incorrect case: input null dupkeypair
950 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest730, TestSize.Level0)
951 {
952 HcfAsyKeyGenerator *rsaGenerator = nullptr;
953 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
954 EXPECT_EQ(res, HCF_SUCCESS);
955 EXPECT_NE(rsaGenerator, nullptr);
956
957 HcfKeyPair *keyPair = nullptr;
958 res = rsaGenerator->generateKeyPair(rsaGenerator, nullptr, &keyPair);
959 EXPECT_EQ(res, HCF_SUCCESS);
960 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
961 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
962 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
963 EXPECT_EQ(res, HCF_SUCCESS);
964 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
965 EXPECT_EQ(res, HCF_SUCCESS);
966
967 res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, nullptr);
968 EXPECT_NE(res, HCF_SUCCESS);
969
970 HcfFree(pubKeyBlob.data);
971 HcfFree(priKeyBlob.data);
972 HcfObjDestroy(keyPair);
973 HcfObjDestroy(rsaGenerator);
974 }
975
976 // convertKey incorrect case: input blob with null data
977 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest740, TestSize.Level0)
978 {
979 HcfAsyKeyGenerator *rsaGenerator = nullptr;
980 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
981 EXPECT_EQ(res, HCF_SUCCESS);
982 EXPECT_NE(rsaGenerator, nullptr);
983
984 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
985 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
986
987 HcfKeyPair *dupKeyPair = nullptr;
988 res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
989 EXPECT_NE(res, HCF_SUCCESS);
990 EXPECT_EQ(dupKeyPair, nullptr);
991
992 HcfObjDestroy(rsaGenerator);
993 }
994
995 // convertKey incorrect case: input blob with zero len
996 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest750, TestSize.Level0)
997 {
998 HcfAsyKeyGenerator *rsaGenerator = nullptr;
999 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &rsaGenerator);
1000 EXPECT_EQ(res, HCF_SUCCESS);
1001 EXPECT_NE(rsaGenerator, nullptr);
1002
1003 HcfBlob pubKeyBlob = {.data = g_rsaCorrectPkData, .len = 0};
1004 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1005
1006 HcfKeyPair *dupKeyPair = nullptr;
1007 res = rsaGenerator->convertKey(rsaGenerator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
1008 EXPECT_NE(res, HCF_SUCCESS);
1009 EXPECT_EQ(dupKeyPair, nullptr);
1010
1011 HcfObjDestroy(rsaGenerator);
1012 }
1013
1014 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest760, TestSize.Level0)
1015 {
1016 HcfAsyKeyGenerator *rsaGenerator = nullptr;
1017 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &rsaGenerator);
1018 EXPECT_EQ(res, HCF_SUCCESS);
1019 EXPECT_NE(rsaGenerator, nullptr);
1020
1021 HcfBlob priKeyBlob = {.data = g_rsaCorrectPkData, .len = 0};
1022
1023 HcfKeyPair *dupKeyPair = nullptr;
1024 res = rsaGenerator->convertKey(rsaGenerator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
1025 EXPECT_NE(res, HCF_SUCCESS);
1026 EXPECT_EQ(dupKeyPair, nullptr);
1027
1028 HcfObjDestroy(rsaGenerator);
1029 }
1030
1031 // convertKey incorrect case: input blob with error data
1032 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest770, TestSize.Level0)
1033 {
1034 HcfAsyKeyGenerator *rsaGenerator = nullptr;
1035 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &rsaGenerator);
1036 EXPECT_EQ(res, HCF_SUCCESS);
1037 EXPECT_NE(rsaGenerator, nullptr);
1038
1039 HcfKeyPair *dupKeyPair = nullptr;
1040 res = rsaGenerator->convertKey(rsaGenerator, nullptr, &g_rsaErrorPubKeyBlob, &g_rsaErrorPubKeyBlob, &dupKeyPair);
1041 EXPECT_NE(res, HCF_SUCCESS);
1042 EXPECT_EQ(dupKeyPair, nullptr);
1043
1044 HcfObjDestroy(rsaGenerator);
1045 }
1046
1047 // Incorrect case: use wrong bits or primes
1048 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest800, TestSize.Level0)
1049 {
1050 HcfAsyKeyGenerator *generator = nullptr;
1051 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1111", &generator);
1052 EXPECT_NE(res, HCF_SUCCESS);
1053 EXPECT_EQ(generator, nullptr);
1054 HcfObjDestroy(generator);
1055 }
1056
1057 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest810, TestSize.Level0)
1058 {
1059 HcfAsyKeyGenerator *generator = nullptr;
1060 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
1061 EXPECT_NE(res, HCF_SUCCESS);
1062 EXPECT_EQ(generator, nullptr);
1063 HcfObjDestroy(generator);
1064 }
1065
1066 // 测试异常释放
1067 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest820, TestSize.Level0)
1068 {
1069 HcfAsyKeyGenerator *generator = nullptr;
1070 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|Primessf", &generator);
1071 EXPECT_NE(res, HCF_SUCCESS);
1072 EXPECT_EQ(generator, nullptr);
1073 HcfObjDestroy(generator);
1074 }
1075
1076 // prikey clear mem
1077 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest830, TestSize.Level0)
1078 {
1079 HcfAsyKeyGenerator *generator = nullptr;
1080 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1081 EXPECT_EQ(res, HCF_SUCCESS);
1082 EXPECT_NE(generator, nullptr);
1083
1084 HcfKeyPair *keyPair = nullptr;
1085 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1086
1087 keyPair->priKey->clearMem(nullptr);
1088
1089 HcfObjDestroy(generator);
1090 HcfObjDestroy(keyPair);
1091 }
1092
1093 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest840, TestSize.Level0)
1094 {
1095 HcfAsyKeyGenerator *generator = nullptr;
1096 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1097 EXPECT_EQ(res, HCF_SUCCESS);
1098 EXPECT_NE(generator, nullptr);
1099
1100 HcfKeyPair *keyPair = nullptr;
1101 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1102
1103 keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey);
1104
1105 HcfObjDestroy(generator);
1106 HcfObjDestroy(keyPair);
1107 }
1108
1109 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest850, TestSize.Level0)
1110 {
1111 HcfAsyKeyGenerator *generator = nullptr;
1112 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1113 EXPECT_EQ(res, HCF_SUCCESS);
1114 EXPECT_NE(generator, nullptr);
1115
1116 HcfKeyPair *keyPair = nullptr;
1117 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1118
1119 keyPair->priKey->clearMem(keyPair->priKey);
1120
1121 HcfObjDestroy(generator);
1122 HcfObjDestroy(keyPair);
1123 }
1124
1125 // correct case: use destroy function inclass(not HcfObjDestroy)
1126 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest900, TestSize.Level0)
1127 {
1128 HcfAsyKeyGenerator *generator = nullptr;
1129 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1130
1131 HcfKeyPair *keyPair = nullptr;
1132 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1133
1134 HcfPubKey *pubkey = keyPair->pubKey;
1135 HcfPriKey *prikey = keyPair->priKey;
1136
1137 EXPECT_EQ(pubkey->base.getFormat((HcfKey *)prikey), nullptr);
1138 EXPECT_EQ(prikey->base.getFormat((HcfKey *)pubkey), nullptr);
1139
1140 EXPECT_EQ(pubkey->base.getFormat(nullptr), nullptr);
1141 EXPECT_EQ(prikey->base.getFormat(nullptr), nullptr);
1142
1143 EXPECT_EQ(pubkey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1144 EXPECT_EQ(prikey->base.getAlgorithm((HcfKey *)pubkey), nullptr);
1145
1146 EXPECT_EQ(pubkey->base.getAlgorithm(nullptr), nullptr);
1147 EXPECT_EQ(prikey->base.getAlgorithm(nullptr), nullptr);
1148
1149 prikey->base.base.destroy(nullptr);
1150 pubkey->base.base.destroy(nullptr);
1151 keyPair->base.destroy(nullptr);
1152
1153 prikey->base.base.destroy((HcfObjectBase *)pubkey);
1154 pubkey->base.base.destroy((HcfObjectBase *)prikey);
1155 keyPair->base.destroy((HcfObjectBase *)prikey);
1156
1157 HcfObjDestroy(keyPair);
1158 HcfObjDestroy(generator);
1159 }
1160
1161 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest901, TestSize.Level0)
1162 {
1163 HcfAsyKeyGenerator *generator = nullptr;
1164 HcfResult res = HcfAsyKeyGeneratorCreate("RSA", &generator);
1165 EXPECT_NE(res, HCF_SUCCESS);
1166 EXPECT_EQ(generator, nullptr);
1167 HcfObjDestroy(generator);
1168 }
1169
1170 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest902, TestSize.Level0)
1171 {
1172 HcfAsyKeyGenerator *generator = nullptr;
1173 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
1174 EXPECT_EQ(res, HCF_SUCCESS);
1175 EXPECT_NE(generator, nullptr);
1176
1177 HcfKeyPair *keyPair = nullptr;
1178 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1179 EXPECT_EQ(res, HCF_SUCCESS);
1180 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
1181 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1182 res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
1183 EXPECT_EQ(res, HCF_SUCCESS);
1184 res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
1185 EXPECT_EQ(res, HCF_SUCCESS);
1186
1187 HcfKeyPair *dupKeyPair = nullptr;
1188 res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &dupKeyPair);
1189 EXPECT_EQ(res, HCF_SUCCESS);
1190
1191 HcfPriKey *prikey = dupKeyPair->priKey;
1192 EXPECT_NE(prikey->base.getAlgorithm((HcfKey *)prikey), nullptr);
1193 EXPECT_NE(prikey->base.getFormat((HcfKey *)prikey), nullptr);
1194 EXPECT_NE(prikey->base.base.getClass(), nullptr);
1195 EXPECT_NE(prikey->base.base.destroy, nullptr);
1196 EXPECT_NE(prikey->clearMem, nullptr);
1197
1198 HcfFree(pubKeyBlob.data);
1199 HcfFree(priKeyBlob.data);
1200 HcfObjDestroy(generator);
1201 HcfObjDestroy(keyPair);
1202 HcfObjDestroy(dupKeyPair);
1203 }
1204
1205 // test RSA key pair get
1206 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest903, TestSize.Level0)
1207 {
1208 HcfAsyKeyGenerator *generator = nullptr;
1209 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
1210 EXPECT_EQ(res, HCF_SUCCESS);
1211 EXPECT_NE(generator, nullptr);
1212
1213 HcfKeyPair *keyPair = nullptr;
1214 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1215 EXPECT_EQ(res, HCF_SUCCESS);
1216 EXPECT_NE(keyPair, nullptr);
1217 HcfPriKey *priKey = keyPair->priKey;
1218 HcfPubKey *pubKey = keyPair->pubKey;
1219
1220 HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
1221 HcfBigInteger returnPriN = { .data = nullptr, .len = 0 };
1222 HcfBigInteger returnE = { .data = nullptr, .len = 0 };
1223 HcfBigInteger returnD = { .data = nullptr, .len = 0 };
1224 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &returnPriN);
1225 EXPECT_EQ(res, HCF_SUCCESS);
1226 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &returnD);
1227 EXPECT_EQ(res, HCF_SUCCESS);
1228 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
1229 EXPECT_EQ(res, HCF_SUCCESS);
1230 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
1231 EXPECT_EQ(res, HCF_SUCCESS);
1232
1233 HcfFree(returnPubN.data);
1234 HcfFree(returnPriN.data);
1235 HcfFree(returnD.data);
1236 HcfFree(returnE.data);
1237 HcfObjDestroy(generator);
1238 HcfObjDestroy(keyPair);
1239 }
1240
1241 // spi create
1242 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest001, TestSize.Level0)
1243 {
1244 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1245 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(nullptr, &spiObj);
1246
1247 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1248 ASSERT_EQ(spiObj, nullptr);
1249 }
1250
1251 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest002, TestSize.Level0)
1252 {
1253 HcfAsyKeyGenParams params = {
1254 .algo = HCF_ALG_RSA,
1255 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1256 .primes = 0,
1257 };
1258
1259 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, nullptr);
1260
1261 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1262 }
1263
1264 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest003, TestSize.Level0)
1265 {
1266 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1267 HcfAsyKeyGenParams params = {
1268 .algo = HCF_ALG_RSA,
1269 .bits = OPENSSL_RSA_KEY_SIZE_ABNORMAL,
1270 .primes = 0,
1271 };
1272
1273 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1274
1275 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1276 ASSERT_EQ(spiObj, nullptr);
1277 }
1278
1279 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest004, TestSize.Level0)
1280 {
1281 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1282 HcfAsyKeyGenParams params = {
1283 .algo = HCF_ALG_RSA,
1284 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1285 .primes = OPENSSL_RSA_PRIMES_ABNORMAL,
1286 };
1287
1288 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1289
1290 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1291 ASSERT_EQ(spiObj, nullptr);
1292 }
1293
1294 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest005, TestSize.Level0)
1295 {
1296 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1297 HcfAsyKeyGenParams params = {
1298 .algo = HCF_ALG_RSA,
1299 .bits = OPENSSL_RSA_KEY_SIZE_4096,
1300 .primes = OPENSSL_RSA_PRIMES_ABNORMAL,
1301 };
1302
1303 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1304
1305 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1306 ASSERT_EQ(spiObj, nullptr);
1307 }
1308
1309 // spi gen keyPair
1310 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest006, TestSize.Level0)
1311 {
1312 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1313 HcfAsyKeyGenParams params = {
1314 .algo = HCF_ALG_RSA,
1315 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1316 .primes = 0,
1317 };
1318
1319 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1320
1321 EXPECT_EQ(res, HCF_SUCCESS);
1322 EXPECT_NE(spiObj, nullptr);
1323
1324 HcfKeyPair *keyPair = nullptr;
1325 res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
1326 EXPECT_EQ(res, HCF_INVALID_PARAMS);
1327 HcfObjDestroy(spiObj);
1328 }
1329
1330 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest007, TestSize.Level0)
1331 {
1332 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1333 HcfAsyKeyGenParams params = {
1334 .algo = HCF_ALG_RSA,
1335 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1336 .primes = 0,
1337 };
1338
1339 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1340
1341 EXPECT_EQ(res, HCF_SUCCESS);
1342 EXPECT_NE(spiObj, nullptr);
1343
1344 res = spiObj->engineGenerateKeyPair(nullptr, nullptr);
1345 EXPECT_EQ(res, HCF_INVALID_PARAMS);
1346 HcfObjDestroy(spiObj);
1347 }
1348
1349 // spi destroy
1350 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest008, TestSize.Level0)
1351 {
1352 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1353 HcfAsyKeyGenParams params = {
1354 .algo = HCF_ALG_RSA,
1355 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1356 .primes = 0,
1357 };
1358
1359 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1360
1361 EXPECT_EQ(res, HCF_SUCCESS);
1362 EXPECT_NE(spiObj, nullptr);
1363
1364 spiObj->base.destroy(nullptr);
1365 HcfObjDestroy(spiObj);
1366 }
1367
1368 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest009, TestSize.Level0)
1369 {
1370 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1371 HcfAsyKeyGenParams params = {
1372 .algo = HCF_ALG_RSA,
1373 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1374 .primes = 0,
1375 };
1376
1377 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1378
1379 EXPECT_EQ(res, HCF_SUCCESS);
1380 EXPECT_NE(spiObj, nullptr);
1381
1382 spiObj->base.destroy(&g_obj);
1383 HcfObjDestroy(spiObj);
1384 }
1385
1386 // spi convert
1387 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest010, TestSize.Level0)
1388 {
1389 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1390 HcfAsyKeyGenParams params = {
1391 .algo = HCF_ALG_RSA,
1392 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1393 .primes = 0,
1394 };
1395
1396 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1397
1398 EXPECT_EQ(res, HCF_SUCCESS);
1399 EXPECT_NE(spiObj, nullptr);
1400
1401 HcfKeyPair *keyPair = nullptr;
1402 res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj,
1403 nullptr, &g_rsaCorrectPubKeyBlob, nullptr, &keyPair);
1404 HcfObjDestroy(spiObj);
1405 }
1406
1407 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest011, TestSize.Level0)
1408 {
1409 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1410 HcfAsyKeyGenParams params = {
1411 .algo = HCF_ALG_RSA,
1412 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1413 .primes = 0,
1414 };
1415
1416 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1417
1418 EXPECT_EQ(res, HCF_SUCCESS);
1419 EXPECT_NE(spiObj, nullptr);
1420
1421 HcfKeyPair *keyPair = nullptr;
1422 res = spiObj->engineConvertKey(nullptr, nullptr, &g_rsaCorrectPubKeyBlob, nullptr, &keyPair);
1423 HcfObjDestroy(spiObj);
1424 }
1425
1426 // spi destroy
1427 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest012, TestSize.Level0)
1428 {
1429 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1430 HcfAsyKeyGenParams params = {
1431 .algo = HCF_ALG_RSA,
1432 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1433 .primes = 0,
1434 };
1435
1436 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1437
1438 EXPECT_EQ(res, HCF_SUCCESS);
1439 EXPECT_NE(spiObj, nullptr);
1440
1441 spiObj->base.destroy(nullptr);
1442 EXPECT_NE(spiObj, nullptr);
1443 HcfObjDestroy(spiObj);
1444 }
1445
1446 HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest013, TestSize.Level0)
1447 {
1448 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1449 HcfAsyKeyGenParams params = {
1450 .algo = HCF_ALG_RSA,
1451 .bits = OPENSSL_RSA_KEY_SIZE_2048,
1452 .primes = 0,
1453 };
1454
1455 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
1456
1457 EXPECT_EQ(res, HCF_SUCCESS);
1458 EXPECT_NE(spiObj, nullptr);
1459
1460 spiObj->base.destroy(&g_obj);
1461 EXPECT_NE(spiObj, nullptr);
1462 HcfObjDestroy(spiObj);
1463 }
1464 }
1465