1 /*
2 * Copyright (C) 2024 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 "detailed_rsa_key_params.h"
23 #include "memory.h"
24 #include "openssl_class.h"
25 #include "openssl_common.h"
26 #include "rsa_common_param_spec.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 class CryptoRsa512AsyKeyGeneratorBySpecTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void CryptoRsa512AsyKeyGeneratorBySpecTest::SetUpTestCase() {}
41
TearDownTestCase()42 void CryptoRsa512AsyKeyGeneratorBySpecTest::TearDownTestCase() {}
43
SetUp()44 void CryptoRsa512AsyKeyGeneratorBySpecTest::SetUp() {}
45
TearDown()46 void CryptoRsa512AsyKeyGeneratorBySpecTest::TearDown() {}
47
48 // ============================= RSA 512 testcase begin =============================
49 // basic generator create test
50 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest001, TestSize.Level0)
51 {
52 HcfRsaCommParamsSpec rsaCommSpec = {};
53 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
54 GenerateRsa512CorrectCommonKeySpec(dataN, &rsaCommSpec);
55
56 HcfAsyKeyGeneratorBySpec *generator = nullptr;
57 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
58 EXPECT_NE(res, HCF_SUCCESS);
59 EXPECT_EQ(generator, nullptr);
60
61 HcfObjDestroy(generator);
62 }
63
64 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest002, TestSize.Level0)
65 {
66 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
67 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
68 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
69 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
70
71 HcfAsyKeyGeneratorBySpec *generator = nullptr;
72 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
73 EXPECT_EQ(res, HCF_SUCCESS);
74 EXPECT_NE(generator, nullptr);
75
76 HcfObjDestroy(generator);
77 }
78
79 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest003, TestSize.Level0)
80 {
81 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
82 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
83 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
84 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
85 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
86
87 HcfAsyKeyGeneratorBySpec *generator = nullptr;
88 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
89 EXPECT_EQ(res, HCF_SUCCESS);
90 EXPECT_NE(generator, nullptr);
91
92 HcfObjDestroy(generator);
93 }
94
95 // test generator by spec genrate key funciton not null
96 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest004, TestSize.Level0)
97 {
98 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
99 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
100 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
101 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
102 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
103
104 HcfAsyKeyGeneratorBySpec *generator = nullptr;
105 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
106 EXPECT_EQ(res, HCF_SUCCESS);
107 EXPECT_NE(generator, nullptr);
108
109 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
110 HcfObjDestroy(generator);
111 }
112
113 // test generator by spec get class string test
114 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest005, TestSize.Level0)
115 {
116 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
117 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
118 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
119 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
120
121 HcfAsyKeyGeneratorBySpec *generator = nullptr;
122 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
123 EXPECT_EQ(res, HCF_SUCCESS);
124 EXPECT_NE(generator, nullptr);
125
126 const char *generatorBySpecClass = generator->base.getClass();
127 EXPECT_STREQ(generatorBySpecClass, g_asyKeyGeneratorBySpecClass);
128 HcfObjDestroy(generator);
129 }
130
131 // test generator by spec get getAlgName string test
132 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest006, TestSize.Level0)
133 {
134 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
135 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
136 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
137 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
138
139 HcfAsyKeyGeneratorBySpec *generator = nullptr;
140 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
141 EXPECT_EQ(res, HCF_SUCCESS);
142 EXPECT_NE(generator, nullptr);
143
144 const char *generatorBySpecAlgName = generator->getAlgName(generator);
145 EXPECT_STREQ(generatorBySpecAlgName, g_rsaAlgName);
146 HcfObjDestroy(generator);
147 }
148
149 // test generator by spec basic destroy
150 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest007, TestSize.Level0)
151 {
152 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
153 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
154 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
155 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
156
157
158 HcfAsyKeyGeneratorBySpec *generator = nullptr;
159 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
160 EXPECT_EQ(res, HCF_SUCCESS);
161 EXPECT_NE(generator, nullptr);
162
163 generator->base.destroy(&(generator->base));
164 }
165 // test correct spec and generate key pair, pri key, and pub key.
166 // pub spec
167 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest008, TestSize.Level0)
168 {
169 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
170 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
171 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
172 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
173
174 HcfAsyKeyGeneratorBySpec *generator = nullptr;
175 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
176 EXPECT_EQ(res, HCF_SUCCESS);
177 EXPECT_NE(generator, nullptr);
178
179 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
180 HcfKeyPair *keyPair = nullptr;
181 res = generator->generateKeyPair(generator, &keyPair);
182 EXPECT_EQ(res, HCF_INVALID_PARAMS);
183 EXPECT_EQ(keyPair, nullptr);
184
185 HcfObjDestroy(keyPair);
186 HcfObjDestroy(generator);
187 }
188
189 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest009, TestSize.Level0)
190 {
191 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
192 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
193 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
194 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
195
196 HcfAsyKeyGeneratorBySpec *generator = nullptr;
197 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
198 EXPECT_EQ(res, HCF_SUCCESS);
199 EXPECT_NE(generator, nullptr);
200
201 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
202 HcfPubKey *pubKey = nullptr;
203 res = generator->generatePubKey(generator, &pubKey);
204 EXPECT_EQ(res, HCF_SUCCESS);
205 EXPECT_NE(pubKey, nullptr);
206
207 HcfObjDestroy(pubKey);
208 HcfObjDestroy(generator);
209 }
210
211 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest140, TestSize.Level0)
212 {
213 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
214 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
215 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
216 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
217
218 HcfAsyKeyGeneratorBySpec *generator = nullptr;
219 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
220 EXPECT_EQ(res, HCF_SUCCESS);
221 EXPECT_NE(generator, nullptr);
222
223 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
224 HcfPriKey *priKey = nullptr;
225 res = generator->generatePriKey(generator, &priKey);
226 EXPECT_EQ(res, HCF_INVALID_PARAMS);
227 EXPECT_EQ(priKey, nullptr);
228
229 HcfObjDestroy(priKey);
230 HcfObjDestroy(generator);
231 }
232
233 // key pair spec
234 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest141, TestSize.Level0)
235 {
236 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
237 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
238 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
239 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
240 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
241
242 HcfAsyKeyGeneratorBySpec *generator = nullptr;
243 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
244 EXPECT_EQ(res, HCF_SUCCESS);
245 EXPECT_NE(generator, nullptr);
246
247 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
248 HcfKeyPair *keyPair = nullptr;
249 res = generator->generateKeyPair(generator, &keyPair);
250 EXPECT_EQ(res, HCF_SUCCESS);
251 EXPECT_NE(keyPair, nullptr);
252
253 HcfObjDestroy(keyPair);
254 HcfObjDestroy(generator);
255 }
256
257 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest142, TestSize.Level0)
258 {
259 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
260 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
261 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
262 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
263 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
264
265 HcfAsyKeyGeneratorBySpec *generator = nullptr;
266 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
267 EXPECT_EQ(res, HCF_SUCCESS);
268 EXPECT_NE(generator, nullptr);
269
270 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
271 HcfPubKey *pubKey = nullptr;
272 res = generator->generatePubKey(generator, &pubKey);
273 EXPECT_EQ(res, HCF_SUCCESS);
274 EXPECT_NE(pubKey, nullptr);
275
276 HcfObjDestroy(pubKey);
277 HcfObjDestroy(generator);
278 }
279
280 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest143, TestSize.Level0)
281 {
282 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
283 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
284 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
285 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
286 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
287
288 HcfAsyKeyGeneratorBySpec *generator = nullptr;
289 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
290 EXPECT_EQ(res, HCF_SUCCESS);
291 EXPECT_NE(generator, nullptr);
292
293 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
294 HcfPriKey *priKey = nullptr;
295 res = generator->generatePriKey(generator, &priKey);
296 EXPECT_EQ(res, HCF_SUCCESS);
297 EXPECT_NE(priKey, nullptr);
298
299 HcfObjDestroy(priKey);
300 HcfObjDestroy(generator);
301 }
302
303 // check normal key function from key pairs of key pair spec
304 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest144, TestSize.Level0)
305 {
306 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
307 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
308 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
309 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
310 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
311
312 HcfAsyKeyGeneratorBySpec *generator = nullptr;
313 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
314 EXPECT_EQ(res, HCF_SUCCESS);
315 EXPECT_NE(generator, nullptr);
316
317 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
318 HcfKeyPair *keyPair = nullptr;
319 res = generator->generateKeyPair(generator, &keyPair);
320 EXPECT_EQ(res, HCF_SUCCESS);
321 EXPECT_NE(keyPair, nullptr);
322
323 const char *keyPairClassName = keyPair->base.getClass();
324 EXPECT_STREQ(keyPairClassName, OPENSSL_RSA_KEYPAIR_CLASS);
325
326 HcfObjDestroy(keyPair);
327 HcfObjDestroy(generator);
328 }
329
330 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest145, TestSize.Level0)
331 {
332 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
333 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
334 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
335 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
336 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
337
338 HcfAsyKeyGeneratorBySpec *generator = nullptr;
339 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
340 EXPECT_EQ(res, HCF_SUCCESS);
341 EXPECT_NE(generator, nullptr);
342
343 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
344 HcfKeyPair *keyPair = nullptr;
345 res = generator->generateKeyPair(generator, &keyPair);
346 EXPECT_EQ(res, HCF_SUCCESS);
347 EXPECT_NE(keyPair, nullptr);
348
349 keyPair->base.destroy(&(keyPair->base));
350 HcfObjDestroy(generator);
351 }
352
353 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest146, TestSize.Level0)
354 {
355 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
356 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
357 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
358 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
359 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
360
361 HcfAsyKeyGeneratorBySpec *generator = nullptr;
362 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
363 EXPECT_EQ(res, HCF_SUCCESS);
364 EXPECT_NE(generator, nullptr);
365
366 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
367 HcfKeyPair *keyPair = nullptr;
368 res = generator->generateKeyPair(generator, &keyPair);
369 EXPECT_EQ(res, HCF_SUCCESS);
370 EXPECT_NE(keyPair, nullptr);
371
372 const char *pkClassName = keyPair->pubKey->base.base.getClass();
373 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
374
375 HcfObjDestroy(keyPair);
376 HcfObjDestroy(generator);
377 }
378
379 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest147, TestSize.Level0)
380 {
381 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
382 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
383 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
384 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
385 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
386
387 HcfAsyKeyGeneratorBySpec *generator = nullptr;
388 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
389 EXPECT_EQ(res, HCF_SUCCESS);
390 EXPECT_NE(generator, nullptr);
391
392 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
393 HcfKeyPair *keyPair = nullptr;
394 res = generator->generateKeyPair(generator, &keyPair);
395 EXPECT_EQ(res, HCF_SUCCESS);
396 EXPECT_NE(keyPair, nullptr);
397
398 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
399 keyPair->pubKey = nullptr;
400 HcfObjDestroy(keyPair);
401 HcfObjDestroy(generator);
402 }
403
404 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest148, TestSize.Level0)
405 {
406 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
407 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
408 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
409 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
410 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
411
412 HcfAsyKeyGeneratorBySpec *generator = nullptr;
413 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
414 EXPECT_EQ(res, HCF_SUCCESS);
415 EXPECT_NE(generator, nullptr);
416
417 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
418 HcfKeyPair *keyPair = nullptr;
419 res = generator->generateKeyPair(generator, &keyPair);
420 EXPECT_EQ(res, HCF_SUCCESS);
421 EXPECT_NE(keyPair, nullptr);
422
423 const char *alg = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
424 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
425 HcfObjDestroy(keyPair);
426 HcfObjDestroy(generator);
427 }
428
429 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest149, TestSize.Level0)
430 {
431 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
432 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
433 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
434 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
435 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
436
437 HcfAsyKeyGeneratorBySpec *generator = nullptr;
438 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
439 EXPECT_EQ(res, HCF_SUCCESS);
440 EXPECT_NE(generator, nullptr);
441
442 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
443 HcfKeyPair *keyPair = nullptr;
444 res = generator->generateKeyPair(generator, &keyPair);
445 EXPECT_EQ(res, HCF_SUCCESS);
446 EXPECT_NE(keyPair, nullptr);
447
448 HcfBlob blob = { .data = nullptr, .len = 0 };
449 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
450 EXPECT_EQ(res, HCF_SUCCESS);
451 EXPECT_NE(blob.data, nullptr);
452 EXPECT_NE(blob.len, 0);
453 HcfFree(blob.data);
454 HcfObjDestroy(keyPair);
455 HcfObjDestroy(generator);
456 }
457
458 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest150, TestSize.Level0)
459 {
460 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
461 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
462 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
463 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
464 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
465
466 HcfAsyKeyGeneratorBySpec *generator = nullptr;
467 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
468 EXPECT_EQ(res, HCF_SUCCESS);
469 EXPECT_NE(generator, nullptr);
470
471 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
472 HcfKeyPair *keyPair = nullptr;
473 res = generator->generateKeyPair(generator, &keyPair);
474 EXPECT_EQ(res, HCF_SUCCESS);
475 EXPECT_NE(keyPair, nullptr);
476
477 const char *pkFormat = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
478 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
479 HcfObjDestroy(keyPair);
480 HcfObjDestroy(generator);
481 }
482
483 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest151, TestSize.Level0)
484 {
485 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
486 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
487 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
488 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
489 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
490
491 HcfAsyKeyGeneratorBySpec *generator = nullptr;
492 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
493 EXPECT_EQ(res, HCF_SUCCESS);
494 EXPECT_NE(generator, nullptr);
495
496 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
497 HcfKeyPair *keyPair = nullptr;
498 res = generator->generateKeyPair(generator, &keyPair);
499 EXPECT_EQ(res, HCF_SUCCESS);
500 EXPECT_NE(keyPair, nullptr);
501
502 HcfBigInteger n = { .data = nullptr, .len = 0 };
503 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_N_BN, &n);
504 EXPECT_EQ(res, HCF_SUCCESS);
505 EXPECT_NE(n.data, nullptr);
506 EXPECT_NE(n.len, 0);
507 res = memcmp(n.data, dataN, RSA_512_N_BYTE_SIZE);
508 EXPECT_EQ(res, 0);
509
510 HcfFree(n.data);
511 HcfObjDestroy(keyPair);
512 HcfObjDestroy(generator);
513 }
514
515 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest152, TestSize.Level0)
516 {
517 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
518 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
519 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
520 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
521 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
522
523 HcfAsyKeyGeneratorBySpec *generator = nullptr;
524 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
525 EXPECT_EQ(res, HCF_SUCCESS);
526 EXPECT_NE(generator, nullptr);
527
528 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
529 HcfKeyPair *keyPair = nullptr;
530 res = generator->generateKeyPair(generator, &keyPair);
531 EXPECT_EQ(res, HCF_SUCCESS);
532 EXPECT_NE(keyPair, nullptr);
533
534 HcfBigInteger e = { .data = nullptr, .len = 0 };
535 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_PK_BN, &e);
536 EXPECT_EQ(res, HCF_SUCCESS);
537 EXPECT_NE(e.data, nullptr);
538 EXPECT_NE(e.len, 0);
539 res = memcmp(e.data, dataE, RSA_512_E_BYTE_SIZE);
540 EXPECT_EQ(res, 0);
541
542 HcfFree(e.data);
543 HcfObjDestroy(keyPair);
544 HcfObjDestroy(generator);
545 }
546
547 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest153, TestSize.Level0)
548 {
549 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
550 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
551 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
552 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
553 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
554
555 HcfAsyKeyGeneratorBySpec *generator = nullptr;
556 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
557 EXPECT_EQ(res, HCF_SUCCESS);
558 EXPECT_NE(generator, nullptr);
559
560 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
561 HcfKeyPair *keyPair = nullptr;
562 res = generator->generateKeyPair(generator, &keyPair);
563 EXPECT_EQ(res, HCF_SUCCESS);
564 EXPECT_NE(keyPair, nullptr);
565
566 const char *skClassName = keyPair->priKey->base.base.getClass();
567 EXPECT_STREQ(skClassName, OPENSSL_RSA_PRIKEY_CLASS);
568 HcfObjDestroy(keyPair);
569 HcfObjDestroy(generator);
570 }
571
572 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest154, TestSize.Level0)
573 {
574 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
575 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
576 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
577 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
578 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
579
580 HcfAsyKeyGeneratorBySpec *generator = nullptr;
581 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
582 EXPECT_EQ(res, HCF_SUCCESS);
583 EXPECT_NE(generator, nullptr);
584
585 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
586 HcfKeyPair *keyPair = nullptr;
587 res = generator->generateKeyPair(generator, &keyPair);
588 EXPECT_EQ(res, HCF_SUCCESS);
589 EXPECT_NE(keyPair, nullptr);
590
591 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
592 keyPair->priKey = nullptr;
593
594 HcfObjDestroy(keyPair);
595 HcfObjDestroy(generator);
596 }
597
598 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest155, TestSize.Level0)
599 {
600 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
601 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
602 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
603 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
604 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
605
606 HcfAsyKeyGeneratorBySpec *generator = nullptr;
607 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
608 EXPECT_EQ(res, HCF_SUCCESS);
609 EXPECT_NE(generator, nullptr);
610
611 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
612 HcfKeyPair *keyPair = nullptr;
613 res = generator->generateKeyPair(generator, &keyPair);
614 EXPECT_EQ(res, HCF_SUCCESS);
615 EXPECT_NE(keyPair, nullptr);
616
617 const char *alg = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
618 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
619
620 HcfObjDestroy(keyPair);
621 HcfObjDestroy(generator);
622 }
623
624 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest156, TestSize.Level0)
625 {
626 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
627 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
628 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
629 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
630 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
631
632 HcfAsyKeyGeneratorBySpec *generator = nullptr;
633 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
634 EXPECT_EQ(res, HCF_SUCCESS);
635 EXPECT_NE(generator, nullptr);
636
637 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
638 HcfKeyPair *keyPair = nullptr;
639 res = generator->generateKeyPair(generator, &keyPair);
640 EXPECT_EQ(res, HCF_SUCCESS);
641 EXPECT_NE(keyPair, nullptr);
642
643 HcfBlob blob = { .data = nullptr, .len = 0 };
644 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
645 EXPECT_EQ(res, HCF_NOT_SUPPORT);
646 EXPECT_EQ(blob.data, nullptr);
647 EXPECT_EQ(blob.len, 0);
648
649 HcfFree(blob.data);
650 HcfObjDestroy(keyPair);
651 HcfObjDestroy(generator);
652 }
653
654 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest157, TestSize.Level0)
655 {
656 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
657 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
658 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
659 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
660 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
661
662 HcfAsyKeyGeneratorBySpec *generator = nullptr;
663 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
664 EXPECT_EQ(res, HCF_SUCCESS);
665 EXPECT_NE(generator, nullptr);
666
667 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
668 HcfKeyPair *keyPair = nullptr;
669 res = generator->generateKeyPair(generator, &keyPair);
670 EXPECT_EQ(res, HCF_SUCCESS);
671 EXPECT_NE(keyPair, nullptr);
672
673 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
674 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
675
676 HcfObjDestroy(keyPair);
677 HcfObjDestroy(generator);
678 }
679
680 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest158, TestSize.Level0)
681 {
682 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
683 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
684 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
685 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
686 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
687
688 HcfAsyKeyGeneratorBySpec *generator = nullptr;
689 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
690 EXPECT_EQ(res, HCF_SUCCESS);
691 EXPECT_NE(generator, nullptr);
692
693 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
694 HcfKeyPair *keyPair = nullptr;
695 res = generator->generateKeyPair(generator, &keyPair);
696 EXPECT_EQ(res, HCF_SUCCESS);
697 EXPECT_NE(keyPair, nullptr);
698
699 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
700 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
701
702 HcfBigInteger n = { .data = nullptr, .len = 0 };
703 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_N_BN, &n);
704 EXPECT_EQ(res, HCF_SUCCESS);
705 EXPECT_NE(n.data, nullptr);
706 EXPECT_NE(n.len, 0);
707
708 HcfFree(n.data);
709 HcfObjDestroy(keyPair);
710 HcfObjDestroy(generator);
711 }
712
713 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest159, TestSize.Level0)
714 {
715 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
716 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
717 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
718 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
719 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
720
721 HcfAsyKeyGeneratorBySpec *generator = nullptr;
722 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
723 EXPECT_EQ(res, HCF_SUCCESS);
724 EXPECT_NE(generator, nullptr);
725
726 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
727 HcfKeyPair *keyPair = nullptr;
728 res = generator->generateKeyPair(generator, &keyPair);
729 EXPECT_EQ(res, HCF_SUCCESS);
730 EXPECT_NE(keyPair, nullptr);
731
732 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
733 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
734
735 HcfBigInteger d = { .data = nullptr, .len = 0 };
736 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_SK_BN, &d);
737 EXPECT_EQ(res, HCF_SUCCESS);
738 EXPECT_NE(d.data, nullptr);
739 EXPECT_NE(d.len, 0);
740
741 HcfFree(d.data);
742 HcfObjDestroy(keyPair);
743 HcfObjDestroy(generator);
744 }
745
746 // check key functions of pub key from key pair spec
747 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest160, TestSize.Level0)
748 {
749 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
750 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
751 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
752 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
753 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
754
755 HcfAsyKeyGeneratorBySpec *generator = nullptr;
756 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
757 EXPECT_EQ(res, HCF_SUCCESS);
758 EXPECT_NE(generator, nullptr);
759
760 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
761 HcfPubKey *pubKey = nullptr;
762 res = generator->generatePubKey(generator, &pubKey);
763 EXPECT_EQ(res, HCF_SUCCESS);
764 EXPECT_NE(pubKey, nullptr);
765
766 const char *pkClassName = pubKey->base.base.getClass();
767 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
768
769 HcfObjDestroy(pubKey);
770 HcfObjDestroy(generator);
771 }
772
773 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest161, TestSize.Level0)
774 {
775 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
776 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
777 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
778 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
779 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
780
781 HcfAsyKeyGeneratorBySpec *generator = nullptr;
782 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
783 EXPECT_EQ(res, HCF_SUCCESS);
784 EXPECT_NE(generator, nullptr);
785
786 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
787 HcfPubKey *pubKey = nullptr;
788 res = generator->generatePubKey(generator, &pubKey);
789 EXPECT_EQ(res, HCF_SUCCESS);
790 EXPECT_NE(pubKey, nullptr);
791
792 pubKey->base.base.destroy(&(pubKey->base.base));
793 HcfObjDestroy(generator);
794 }
795
796 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest162, TestSize.Level0)
797 {
798 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
799 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
800 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
801 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
802 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
803
804 HcfAsyKeyGeneratorBySpec *generator = nullptr;
805 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
806 EXPECT_EQ(res, HCF_SUCCESS);
807 EXPECT_NE(generator, nullptr);
808
809 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
810 HcfPubKey *pubKey = nullptr;
811 res = generator->generatePubKey(generator, &pubKey);
812 EXPECT_EQ(res, HCF_SUCCESS);
813 EXPECT_NE(pubKey, nullptr);
814
815 const char *alg = pubKey->base.getAlgorithm(&(pubKey->base));
816 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
817 HcfObjDestroy(pubKey);
818 HcfObjDestroy(generator);
819 }
820
821 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest163, TestSize.Level0)
822 {
823 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
824 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
825 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
826 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
827 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
828
829 HcfAsyKeyGeneratorBySpec *generator = nullptr;
830 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
831 EXPECT_EQ(res, HCF_SUCCESS);
832 EXPECT_NE(generator, nullptr);
833
834 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
835 HcfPubKey *pubKey = nullptr;
836 res = generator->generatePubKey(generator, &pubKey);
837 EXPECT_EQ(res, HCF_SUCCESS);
838 EXPECT_NE(pubKey, nullptr);
839
840 HcfBlob blob = { .data = nullptr, .len = 0 };
841 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
842 EXPECT_EQ(res, HCF_SUCCESS);
843 EXPECT_NE(blob.data, nullptr);
844 EXPECT_NE(blob.len, 0);
845 HcfFree(blob.data);
846 HcfObjDestroy(pubKey);
847 HcfObjDestroy(generator);
848 }
849
850 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest164, TestSize.Level0)
851 {
852 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
853 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
854 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
855 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
856 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
857
858 HcfAsyKeyGeneratorBySpec *generator = nullptr;
859 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
860 EXPECT_EQ(res, HCF_SUCCESS);
861 EXPECT_NE(generator, nullptr);
862
863 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
864 HcfPubKey *pubKey = nullptr;
865 res = generator->generatePubKey(generator, &pubKey);
866 EXPECT_EQ(res, HCF_SUCCESS);
867 EXPECT_NE(pubKey, nullptr);
868
869 const char *pkFormat = pubKey->base.getFormat(&(pubKey->base));
870 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
871 HcfObjDestroy(pubKey);
872 HcfObjDestroy(generator);
873 }
874
875 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest165, TestSize.Level0)
876 {
877 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
878 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
879 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
880 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
881 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
882
883 HcfAsyKeyGeneratorBySpec *generator = nullptr;
884 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
885 EXPECT_EQ(res, HCF_SUCCESS);
886 EXPECT_NE(generator, nullptr);
887
888 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
889 HcfPubKey *pubKey = nullptr;
890 res = generator->generatePubKey(generator, &pubKey);
891 EXPECT_EQ(res, HCF_SUCCESS);
892 EXPECT_NE(pubKey, nullptr);
893
894 HcfBigInteger n = { .data = nullptr, .len = 0 };
895 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &n);
896 EXPECT_EQ(res, HCF_SUCCESS);
897 EXPECT_NE(n.data, nullptr);
898 EXPECT_NE(n.len, 0);
899 res = memcmp(n.data, dataN, RSA_512_N_BYTE_SIZE);
900 EXPECT_EQ(res, 0);
901
902 HcfFree(n.data);
903 HcfObjDestroy(pubKey);
904 HcfObjDestroy(generator);
905 }
906
907 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest166, TestSize.Level0)
908 {
909 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
910 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
911 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
912 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
913 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
914
915 HcfAsyKeyGeneratorBySpec *generator = nullptr;
916 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
917 EXPECT_EQ(res, HCF_SUCCESS);
918 EXPECT_NE(generator, nullptr);
919
920 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
921 HcfPubKey *pubKey = nullptr;
922 res = generator->generatePubKey(generator, &pubKey);
923 EXPECT_EQ(res, HCF_SUCCESS);
924 EXPECT_NE(pubKey, nullptr);
925
926 HcfBigInteger e = { .data = nullptr, .len = 0 };
927 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &e);
928 EXPECT_EQ(res, HCF_SUCCESS);
929 EXPECT_NE(e.data, nullptr);
930 EXPECT_NE(e.len, 0);
931 res = memcmp(e.data, dataE, RSA_512_E_BYTE_SIZE);
932 EXPECT_EQ(res, 0);
933
934 HcfFree(e.data);
935 HcfObjDestroy(pubKey);
936 HcfObjDestroy(generator);
937 }
938
939 // check key function of pri key generated by key pair spec
940 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest167, TestSize.Level0)
941 {
942 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
943 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
944 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
945 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
946 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
947
948 HcfAsyKeyGeneratorBySpec *generator = nullptr;
949 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
950 EXPECT_EQ(res, HCF_SUCCESS);
951 EXPECT_NE(generator, nullptr);
952
953 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
954 HcfPriKey *priKey = nullptr;
955 res = generator->generatePriKey(generator, &priKey);
956 EXPECT_EQ(res, HCF_SUCCESS);
957 EXPECT_NE(priKey, nullptr);
958
959 const char *pkClassName = priKey->base.base.getClass();
960 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PRIKEY_CLASS);
961
962 HcfObjDestroy(priKey);
963 HcfObjDestroy(generator);
964 }
965
966 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest168, TestSize.Level0)
967 {
968 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
969 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
970 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
971 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
972 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
973
974 HcfAsyKeyGeneratorBySpec *generator = nullptr;
975 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
976 EXPECT_EQ(res, HCF_SUCCESS);
977 EXPECT_NE(generator, nullptr);
978
979 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
980 HcfPriKey *priKey = nullptr;
981 res = generator->generatePriKey(generator, &priKey);
982 EXPECT_EQ(res, HCF_SUCCESS);
983 EXPECT_NE(priKey, nullptr);
984
985 priKey->base.base.destroy(&(priKey->base.base));
986 HcfObjDestroy(generator);
987 }
988
989 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest169, TestSize.Level0)
990 {
991 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
992 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
993 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
994 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
995 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
996
997 HcfAsyKeyGeneratorBySpec *generator = nullptr;
998 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
999 EXPECT_EQ(res, HCF_SUCCESS);
1000 EXPECT_NE(generator, nullptr);
1001
1002 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1003 HcfPriKey *priKey = nullptr;
1004 res = generator->generatePriKey(generator, &priKey);
1005 EXPECT_EQ(res, HCF_SUCCESS);
1006 EXPECT_NE(priKey, nullptr);
1007
1008 const char *alg = priKey->base.getAlgorithm(&(priKey->base));
1009 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
1010 HcfObjDestroy(priKey);
1011 HcfObjDestroy(generator);
1012 }
1013
1014 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest170, TestSize.Level0)
1015 {
1016 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1017 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1018 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1019 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1020 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1021
1022 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1023 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1024 EXPECT_EQ(res, HCF_SUCCESS);
1025 EXPECT_NE(generator, nullptr);
1026
1027 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1028 HcfPriKey *priKey = nullptr;
1029 res = generator->generatePriKey(generator, &priKey);
1030 EXPECT_EQ(res, HCF_SUCCESS);
1031 EXPECT_NE(priKey, nullptr);
1032
1033 HcfBlob blob = { .data = nullptr, .len = 0 };
1034 res = priKey->base.getEncoded(&(priKey->base), &blob);
1035 EXPECT_EQ(res, HCF_NOT_SUPPORT);
1036 EXPECT_EQ(blob.data, nullptr);
1037 EXPECT_EQ(blob.len, 0);
1038 HcfFree(blob.data);
1039 HcfObjDestroy(priKey);
1040 HcfObjDestroy(generator);
1041 }
1042
1043 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest171, TestSize.Level0)
1044 {
1045 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1046 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1047 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1048 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1049 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1050
1051 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1052 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1053 EXPECT_EQ(res, HCF_SUCCESS);
1054 EXPECT_NE(generator, nullptr);
1055
1056 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1057 HcfPriKey *priKey = nullptr;
1058 res = generator->generatePriKey(generator, &priKey);
1059 EXPECT_EQ(res, HCF_SUCCESS);
1060 EXPECT_NE(priKey, nullptr);
1061
1062 const char *pkFormat = priKey->base.getFormat(&(priKey->base));
1063 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
1064 HcfObjDestroy(priKey);
1065 HcfObjDestroy(generator);
1066 }
1067
1068 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest172, TestSize.Level0)
1069 {
1070 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1071 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1072 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1073 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1074 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1075
1076 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1077 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1078 EXPECT_EQ(res, HCF_SUCCESS);
1079 EXPECT_NE(generator, nullptr);
1080
1081 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1082 HcfPriKey *priKey = nullptr;
1083 res = generator->generatePriKey(generator, &priKey);
1084 EXPECT_EQ(res, HCF_SUCCESS);
1085 EXPECT_NE(priKey, nullptr);
1086
1087 HcfBigInteger n = { .data = nullptr, .len = 0 };
1088 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &n);
1089 EXPECT_EQ(res, HCF_SUCCESS);
1090 EXPECT_NE(n.data, nullptr);
1091 EXPECT_NE(n.len, 0);
1092 res = memcmp(n.data, dataN, RSA_512_N_BYTE_SIZE);
1093 EXPECT_EQ(res, 0);
1094
1095 HcfFree(n.data);
1096 HcfObjDestroy(priKey);
1097 HcfObjDestroy(generator);
1098 }
1099
1100 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest173, TestSize.Level0)
1101 {
1102 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1103 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1104 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1105 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1106 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1107
1108 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1109 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1110 EXPECT_EQ(res, HCF_SUCCESS);
1111 EXPECT_NE(generator, nullptr);
1112
1113 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1114 HcfPriKey *priKey = nullptr;
1115 res = generator->generatePriKey(generator, &priKey);
1116 EXPECT_EQ(res, HCF_SUCCESS);
1117 EXPECT_NE(priKey, nullptr);
1118
1119 HcfBigInteger d = { .data = nullptr, .len = 0 };
1120 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &d);
1121 EXPECT_EQ(res, HCF_SUCCESS);
1122 EXPECT_NE(d.data, nullptr);
1123 EXPECT_NE(d.len, 0);
1124 res = memcmp(d.data, dataD, RSA_512_D_BYTE_SIZE);
1125 EXPECT_EQ(res, 0);
1126
1127 HcfFree(d.data);
1128 HcfObjDestroy(priKey);
1129 HcfObjDestroy(generator);
1130 }
1131
1132 // check key functions of pub key from pub key spec
1133 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest174, TestSize.Level0)
1134 {
1135 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1136 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1137 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1138 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1139 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1140 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1141 EXPECT_EQ(res, HCF_SUCCESS);
1142 EXPECT_NE(generator, nullptr);
1143
1144 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1145 HcfPubKey *pubKey = nullptr;
1146 res = generator->generatePubKey(generator, &pubKey);
1147 EXPECT_EQ(res, HCF_SUCCESS);
1148 EXPECT_NE(pubKey, nullptr);
1149
1150 const char *pkClassName = pubKey->base.base.getClass();
1151 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
1152
1153 HcfObjDestroy(pubKey);
1154 HcfObjDestroy(generator);
1155 }
1156
1157 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest175, TestSize.Level0)
1158 {
1159 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1160 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1161 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1162 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1163 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1164 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1165 EXPECT_EQ(res, HCF_SUCCESS);
1166 EXPECT_NE(generator, nullptr);
1167
1168 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1169 HcfPubKey *pubKey = nullptr;
1170 res = generator->generatePubKey(generator, &pubKey);
1171 EXPECT_EQ(res, HCF_SUCCESS);
1172 EXPECT_NE(pubKey, nullptr);
1173
1174 pubKey->base.base.destroy(&(pubKey->base.base));
1175 HcfObjDestroy(generator);
1176 }
1177
1178 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest176, TestSize.Level0)
1179 {
1180 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1181 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1182 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1183 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1184 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1185 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1186 EXPECT_EQ(res, HCF_SUCCESS);
1187 EXPECT_NE(generator, nullptr);
1188
1189 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1190 HcfPubKey *pubKey = nullptr;
1191 res = generator->generatePubKey(generator, &pubKey);
1192 EXPECT_EQ(res, HCF_SUCCESS);
1193 EXPECT_NE(pubKey, nullptr);
1194
1195 const char *alg = pubKey->base.getAlgorithm(&(pubKey->base));
1196 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
1197 HcfObjDestroy(pubKey);
1198 HcfObjDestroy(generator);
1199 }
1200
1201 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest177, TestSize.Level0)
1202 {
1203 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1204 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1205 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1206 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1207 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1208 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1209 EXPECT_EQ(res, HCF_SUCCESS);
1210 EXPECT_NE(generator, nullptr);
1211
1212 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1213 HcfPubKey *pubKey = nullptr;
1214 res = generator->generatePubKey(generator, &pubKey);
1215 EXPECT_EQ(res, HCF_SUCCESS);
1216 EXPECT_NE(pubKey, nullptr);
1217
1218 HcfBlob blob = { .data = nullptr, .len = 0 };
1219 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1220 EXPECT_EQ(res, HCF_SUCCESS);
1221 EXPECT_NE(blob.data, nullptr);
1222 EXPECT_NE(blob.len, 0);
1223 HcfFree(blob.data);
1224 HcfObjDestroy(pubKey);
1225 HcfObjDestroy(generator);
1226 }
1227
1228 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest178, TestSize.Level0)
1229 {
1230 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1231 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1232 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1233 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1234 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1235 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1236 EXPECT_EQ(res, HCF_SUCCESS);
1237 EXPECT_NE(generator, nullptr);
1238
1239 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1240 HcfPubKey *pubKey = nullptr;
1241 res = generator->generatePubKey(generator, &pubKey);
1242 EXPECT_EQ(res, HCF_SUCCESS);
1243 EXPECT_NE(pubKey, nullptr);
1244
1245 const char *pkFormat = pubKey->base.getFormat(&(pubKey->base));
1246 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
1247 HcfObjDestroy(pubKey);
1248 HcfObjDestroy(generator);
1249 }
1250
1251 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest179, TestSize.Level0)
1252 {
1253 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1254 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1255 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1256 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1257 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1258 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1259 EXPECT_EQ(res, HCF_SUCCESS);
1260 EXPECT_NE(generator, nullptr);
1261
1262 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1263 HcfPubKey *pubKey = nullptr;
1264 res = generator->generatePubKey(generator, &pubKey);
1265 EXPECT_EQ(res, HCF_SUCCESS);
1266 EXPECT_NE(pubKey, nullptr);
1267
1268 HcfBigInteger n = { .data = nullptr, .len = 0 };
1269 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &n);
1270 EXPECT_EQ(res, HCF_SUCCESS);
1271 EXPECT_NE(n.data, nullptr);
1272 EXPECT_NE(n.len, 0);
1273 res = memcmp(n.data, dataN, RSA_512_N_BYTE_SIZE);
1274 EXPECT_EQ(res, 0);
1275
1276 HcfFree(n.data);
1277 HcfObjDestroy(pubKey);
1278 HcfObjDestroy(generator);
1279 }
1280
1281 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest180, TestSize.Level0)
1282 {
1283 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1284 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1285 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1286 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1287 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1288 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1289 EXPECT_EQ(res, HCF_SUCCESS);
1290 EXPECT_NE(generator, nullptr);
1291
1292 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1293 HcfPubKey *pubKey = nullptr;
1294 res = generator->generatePubKey(generator, &pubKey);
1295 EXPECT_EQ(res, HCF_SUCCESS);
1296 EXPECT_NE(pubKey, nullptr);
1297
1298 HcfBigInteger e = { .data = nullptr, .len = 0 };
1299 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &e);
1300 EXPECT_EQ(res, HCF_SUCCESS);
1301 EXPECT_NE(e.data, nullptr);
1302 EXPECT_NE(e.len, 0);
1303 res = memcmp(e.data, dataE, RSA_512_E_BYTE_SIZE);
1304 EXPECT_EQ(res, 0);
1305
1306 HcfFree(e.data);
1307 HcfObjDestroy(pubKey);
1308 HcfObjDestroy(generator);
1309 }
1310
1311 // check encoded key pair's pub key from key pair spec and convert to pub key object
1312 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest181, TestSize.Level0)
1313 {
1314 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1315 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1316 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1317 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1318 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1319
1320 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1321 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1322 EXPECT_EQ(res, HCF_SUCCESS);
1323 EXPECT_NE(generator, nullptr);
1324
1325 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1326 HcfKeyPair *keyPair = nullptr;
1327 res = generator->generateKeyPair(generator, &keyPair);
1328 EXPECT_EQ(res, HCF_SUCCESS);
1329 EXPECT_NE(keyPair, nullptr);
1330
1331 // encoded and convert key pair's pubKey
1332 HcfPubKey *pubKey = keyPair->pubKey;
1333 HcfBlob blob = { .data = nullptr, .len = 0 };
1334 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1335 EXPECT_EQ(res, HCF_SUCCESS);
1336 EXPECT_NE(blob.data, nullptr);
1337 EXPECT_NE(blob.len, 0);
1338
1339 HcfAsyKeyGenerator *generatorConvert = nullptr;
1340 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1341 EXPECT_EQ(res, HCF_SUCCESS);
1342 EXPECT_NE(generatorConvert, nullptr);
1343
1344 HcfKeyPair *dupKeyPair = nullptr;
1345 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1346 EXPECT_EQ(res, HCF_SUCCESS);
1347 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1348 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1349
1350 HcfFree(blob.data);
1351 HcfObjDestroy(keyPair);
1352 HcfObjDestroy(dupKeyPair);
1353 HcfObjDestroy(generator);
1354 HcfObjDestroy(generatorConvert);
1355 }
1356
1357 // check encoded pub key from key pair spec and convert to pub key object
1358 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest182, TestSize.Level0)
1359 {
1360 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1361 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1362 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1363 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1364 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1365
1366 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1367 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1368 EXPECT_EQ(res, HCF_SUCCESS);
1369 EXPECT_NE(generator, nullptr);
1370
1371 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1372 HcfPubKey *pubKey = nullptr;
1373 res = generator->generatePubKey(generator, &pubKey);
1374 EXPECT_EQ(res, HCF_SUCCESS);
1375 EXPECT_NE(pubKey, nullptr);
1376
1377 // encoded and convert pubKey
1378 HcfBlob blob = { .data = nullptr, .len = 0 };
1379 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1380 EXPECT_EQ(res, HCF_SUCCESS);
1381 EXPECT_NE(blob.data, nullptr);
1382 EXPECT_NE(blob.len, 0);
1383
1384 HcfAsyKeyGenerator *generatorConvert = nullptr;
1385 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1386 EXPECT_EQ(res, HCF_SUCCESS);
1387 EXPECT_NE(generatorConvert, nullptr);
1388
1389 HcfKeyPair *dupKeyPair = nullptr;
1390 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1391 EXPECT_EQ(res, HCF_SUCCESS);
1392 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1393 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1394
1395 HcfFree(blob.data);
1396 HcfObjDestroy(dupKeyPair);
1397 HcfObjDestroy(pubKey);
1398 HcfObjDestroy(generator);
1399 HcfObjDestroy(generatorConvert);
1400 }
1401
1402 // check encoded pub key from pub key spec and convert to pub key object
1403 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest183, TestSize.Level0)
1404 {
1405 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1406 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1407 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1408 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1409 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1410 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1411 EXPECT_EQ(res, HCF_SUCCESS);
1412 EXPECT_NE(generator, nullptr);
1413
1414 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1415 HcfPubKey *pubKey = nullptr;
1416 res = generator->generatePubKey(generator, &pubKey);
1417 EXPECT_EQ(res, HCF_SUCCESS);
1418 EXPECT_NE(pubKey, nullptr);
1419
1420 // encoded and convert pubKey
1421 HcfBlob blob = { .data = nullptr, .len = 0 };
1422 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1423 EXPECT_EQ(res, HCF_SUCCESS);
1424 EXPECT_NE(blob.data, nullptr);
1425 EXPECT_NE(blob.len, 0);
1426
1427 HcfAsyKeyGenerator *generatorConvert = nullptr;
1428 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1429 EXPECT_EQ(res, HCF_SUCCESS);
1430 EXPECT_NE(generatorConvert, nullptr);
1431
1432 HcfKeyPair *dupKeyPair = nullptr;
1433 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1434 EXPECT_EQ(res, HCF_SUCCESS);
1435 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1436 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1437
1438 HcfFree(blob.data);
1439 HcfObjDestroy(dupKeyPair);
1440 HcfObjDestroy(pubKey);
1441 HcfObjDestroy(generator);
1442 HcfObjDestroy(generatorConvert);
1443 }
1444
1445 // check encoded key pair's pub key from key pair spec, convert to pub key object and check the get function
1446 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest184, TestSize.Level0)
1447 {
1448 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1449 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1450 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1451 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1452 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1453
1454 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1455 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1456 EXPECT_EQ(res, HCF_SUCCESS);
1457 EXPECT_NE(generator, nullptr);
1458
1459 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1460 HcfKeyPair *keyPair = nullptr;
1461 res = generator->generateKeyPair(generator, &keyPair);
1462 EXPECT_EQ(res, HCF_SUCCESS);
1463 EXPECT_NE(keyPair, nullptr);
1464
1465 // encoded and convert key pair's pubKey
1466 HcfPubKey *pubKey = keyPair->pubKey;
1467 HcfBlob blob = { .data = nullptr, .len = 0 };
1468 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1469 EXPECT_EQ(res, HCF_SUCCESS);
1470 EXPECT_NE(blob.data, nullptr);
1471 EXPECT_NE(blob.len, 0);
1472
1473 HcfAsyKeyGenerator *generatorConvert = nullptr;
1474 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1475 EXPECT_EQ(res, HCF_SUCCESS);
1476 EXPECT_NE(generatorConvert, nullptr);
1477
1478 HcfKeyPair *dupKeyPair = nullptr;
1479 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1480 EXPECT_EQ(res, HCF_SUCCESS);
1481 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1482 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1483
1484 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1485 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1486 EXPECT_EQ(res, HCF_SUCCESS);
1487 EXPECT_NE(dupE.data, nullptr);
1488 EXPECT_NE(dupE.len, 0);
1489 res = memcmp(dupE.data, dataE, RSA_512_E_BYTE_SIZE);
1490 EXPECT_EQ(res, 0);
1491
1492 HcfFree(blob.data);
1493 HcfFree(dupE.data);
1494 HcfObjDestroy(keyPair);
1495 HcfObjDestroy(dupKeyPair);
1496 HcfObjDestroy(generator);
1497 HcfObjDestroy(generatorConvert);
1498 }
1499
1500 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest185, TestSize.Level0)
1501 {
1502 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1503 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1504 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1505 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1506 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1507
1508 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1509 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1510 EXPECT_EQ(res, HCF_SUCCESS);
1511 EXPECT_NE(generator, nullptr);
1512
1513 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1514 HcfKeyPair *keyPair = nullptr;
1515 res = generator->generateKeyPair(generator, &keyPair);
1516 EXPECT_EQ(res, HCF_SUCCESS);
1517 EXPECT_NE(keyPair, nullptr);
1518
1519 // encoded and convert key pair's pubKey
1520 HcfPubKey *pubKey = keyPair->pubKey;
1521 HcfBlob blob = { .data = nullptr, .len = 0 };
1522 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1523 EXPECT_EQ(res, HCF_SUCCESS);
1524 EXPECT_NE(blob.data, nullptr);
1525 EXPECT_NE(blob.len, 0);
1526
1527 HcfAsyKeyGenerator *generatorConvert = nullptr;
1528 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1529 EXPECT_EQ(res, HCF_SUCCESS);
1530 EXPECT_NE(generatorConvert, nullptr);
1531
1532 HcfKeyPair *dupKeyPair = nullptr;
1533 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1534 EXPECT_EQ(res, HCF_SUCCESS);
1535 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1536 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1537
1538 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1539 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1540 EXPECT_EQ(res, HCF_SUCCESS);
1541 EXPECT_NE(dupN.data, nullptr);
1542 EXPECT_NE(dupN.len, 0);
1543 res = memcmp(dupN.data, dataN, RSA_512_N_BYTE_SIZE);
1544 EXPECT_EQ(res, 0);
1545
1546 HcfFree(blob.data);
1547 HcfFree(dupN.data);
1548 HcfObjDestroy(keyPair);
1549 HcfObjDestroy(dupKeyPair);
1550 HcfObjDestroy(generator);
1551 HcfObjDestroy(generatorConvert);
1552 }
1553
1554 // check encoded pub key from key pair spec, convert to pub key object and check the get function
1555 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest186, TestSize.Level0)
1556 {
1557 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1558 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1559 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1560 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1561 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1562
1563 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1564 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1565 EXPECT_EQ(res, HCF_SUCCESS);
1566 EXPECT_NE(generator, nullptr);
1567
1568 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1569 HcfPubKey *pubKey = nullptr;
1570 res = generator->generatePubKey(generator, &pubKey);
1571 EXPECT_EQ(res, HCF_SUCCESS);
1572 EXPECT_NE(pubKey, nullptr);
1573
1574 // encoded and convert key pair's pubKey
1575 HcfBlob blob = { .data = nullptr, .len = 0 };
1576 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1577 EXPECT_EQ(res, HCF_SUCCESS);
1578 EXPECT_NE(blob.data, nullptr);
1579 EXPECT_NE(blob.len, 0);
1580
1581 HcfAsyKeyGenerator *generatorConvert = nullptr;
1582 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1583 EXPECT_EQ(res, HCF_SUCCESS);
1584 EXPECT_NE(generatorConvert, nullptr);
1585
1586 HcfKeyPair *dupKeyPair = nullptr;
1587 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1588 EXPECT_EQ(res, HCF_SUCCESS);
1589 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1590 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1591
1592 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1593 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1594 EXPECT_EQ(res, HCF_SUCCESS);
1595 EXPECT_NE(dupE.data, nullptr);
1596 EXPECT_NE(dupE.len, 0);
1597 res = memcmp(dupE.data, dataE, RSA_512_E_BYTE_SIZE);
1598 EXPECT_EQ(res, 0);
1599
1600 HcfFree(blob.data);
1601 HcfFree(dupE.data);
1602 HcfObjDestroy(pubKey);
1603 HcfObjDestroy(dupKeyPair);
1604 HcfObjDestroy(generator);
1605 HcfObjDestroy(generatorConvert);
1606 }
1607
1608 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest187, TestSize.Level0)
1609 {
1610 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1611 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1612 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1613 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1614 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1615
1616 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1617 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1618 EXPECT_EQ(res, HCF_SUCCESS);
1619 EXPECT_NE(generator, nullptr);
1620
1621 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1622 HcfPubKey *pubKey = nullptr;
1623 res = generator->generatePubKey(generator, &pubKey);
1624 EXPECT_EQ(res, HCF_SUCCESS);
1625 EXPECT_NE(pubKey, nullptr);
1626
1627 // encoded and convert key pair's pubKey
1628 HcfBlob blob = { .data = nullptr, .len = 0 };
1629 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1630 EXPECT_EQ(res, HCF_SUCCESS);
1631 EXPECT_NE(blob.data, nullptr);
1632 EXPECT_NE(blob.len, 0);
1633
1634 HcfAsyKeyGenerator *generatorConvert = nullptr;
1635 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1636 EXPECT_EQ(res, HCF_SUCCESS);
1637 EXPECT_NE(generatorConvert, nullptr);
1638
1639 HcfKeyPair *dupKeyPair = nullptr;
1640 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1641 EXPECT_EQ(res, HCF_SUCCESS);
1642 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1643 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1644
1645 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1646 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1647 EXPECT_EQ(res, HCF_SUCCESS);
1648 EXPECT_NE(dupN.data, nullptr);
1649 EXPECT_NE(dupN.len, 0);
1650 res = memcmp(dupN.data, dataN, RSA_512_N_BYTE_SIZE);
1651 EXPECT_EQ(res, 0);
1652
1653 HcfFree(blob.data);
1654 HcfFree(dupN.data);
1655 HcfObjDestroy(pubKey);
1656 HcfObjDestroy(dupKeyPair);
1657 HcfObjDestroy(generator);
1658 HcfObjDestroy(generatorConvert);
1659 }
1660
1661 // check encoded pub key from pubKey spec, convert to pub key object and check the get function
1662 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest188, TestSize.Level0)
1663 {
1664 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1665 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1666 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1667 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1668 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1669 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1670 EXPECT_EQ(res, HCF_SUCCESS);
1671 EXPECT_NE(generator, nullptr);
1672
1673 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1674 HcfPubKey *pubKey = nullptr;
1675 res = generator->generatePubKey(generator, &pubKey);
1676 EXPECT_EQ(res, HCF_SUCCESS);
1677 EXPECT_NE(pubKey, nullptr);
1678
1679 // encoded and convert pubKey
1680 HcfBlob blob = { .data = nullptr, .len = 0 };
1681 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1682 EXPECT_EQ(res, HCF_SUCCESS);
1683 EXPECT_NE(blob.data, nullptr);
1684 EXPECT_NE(blob.len, 0);
1685
1686 HcfAsyKeyGenerator *generatorConvert = nullptr;
1687 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1688 EXPECT_EQ(res, HCF_SUCCESS);
1689 EXPECT_NE(generatorConvert, nullptr);
1690
1691 HcfKeyPair *dupKeyPair = nullptr;
1692 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1693 EXPECT_EQ(res, HCF_SUCCESS);
1694 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1695 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1696
1697 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1698 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1699 EXPECT_EQ(res, HCF_SUCCESS);
1700 EXPECT_NE(dupE.data, nullptr);
1701 EXPECT_NE(dupE.len, 0);
1702 res = memcmp(dupE.data, dataE, RSA_512_E_BYTE_SIZE);
1703 EXPECT_EQ(res, 0);
1704
1705 HcfFree(blob.data);
1706 HcfFree(dupE.data);
1707 HcfObjDestroy(dupKeyPair);
1708 HcfObjDestroy(pubKey);
1709 HcfObjDestroy(generator);
1710 HcfObjDestroy(generatorConvert);
1711 }
1712
1713 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest189, TestSize.Level0)
1714 {
1715 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1716 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1717 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1718 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1719 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1720 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1721 EXPECT_EQ(res, HCF_SUCCESS);
1722 EXPECT_NE(generator, nullptr);
1723
1724 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1725 HcfPubKey *pubKey = nullptr;
1726 res = generator->generatePubKey(generator, &pubKey);
1727 EXPECT_EQ(res, HCF_SUCCESS);
1728 EXPECT_NE(pubKey, nullptr);
1729
1730 // encoded and convert pubKey
1731 HcfBlob blob = { .data = nullptr, .len = 0 };
1732 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1733 EXPECT_EQ(res, HCF_SUCCESS);
1734 EXPECT_NE(blob.data, nullptr);
1735 EXPECT_NE(blob.len, 0);
1736
1737 HcfAsyKeyGenerator *generatorConvert = nullptr;
1738 res = HcfAsyKeyGeneratorCreate("RSA512", &generatorConvert);
1739 EXPECT_EQ(res, HCF_SUCCESS);
1740 EXPECT_NE(generatorConvert, nullptr);
1741
1742 HcfKeyPair *dupKeyPair = nullptr;
1743 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1744 EXPECT_EQ(res, HCF_SUCCESS);
1745 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1746 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1747
1748 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1749 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1750 EXPECT_EQ(res, HCF_SUCCESS);
1751 EXPECT_NE(dupN.data, nullptr);
1752 EXPECT_NE(dupN.len, 0);
1753 res = memcmp(dupN.data, dataN, RSA_512_N_BYTE_SIZE);
1754 EXPECT_EQ(res, 0);
1755
1756 HcfFree(blob.data);
1757 HcfFree(dupN.data);
1758 HcfObjDestroy(dupKeyPair);
1759 HcfObjDestroy(pubKey);
1760 HcfObjDestroy(generator);
1761 HcfObjDestroy(generatorConvert);
1762 }
1763
1764 // check invalid get key functions of key pair's pub key from key pair spec
1765 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest190, TestSize.Level0)
1766 {
1767 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1768 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1769 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1770 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1771 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1772
1773 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1774 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1775 EXPECT_EQ(res, HCF_SUCCESS);
1776 EXPECT_NE(generator, nullptr);
1777
1778 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1779 HcfKeyPair *keyPair = nullptr;
1780 res = generator->generateKeyPair(generator, &keyPair);
1781 EXPECT_EQ(res, HCF_SUCCESS);
1782 EXPECT_NE(keyPair, nullptr);
1783
1784 EXPECT_NE(keyPair->pubKey->getAsyKeySpecInt, nullptr);
1785
1786 HcfObjDestroy(keyPair);
1787 HcfObjDestroy(generator);
1788 }
1789
1790 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest191, TestSize.Level0)
1791 {
1792 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1793 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1794 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1795 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1796 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1797
1798 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1799 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1800 EXPECT_EQ(res, HCF_SUCCESS);
1801 EXPECT_NE(generator, nullptr);
1802
1803 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1804 HcfKeyPair *keyPair = nullptr;
1805 res = generator->generateKeyPair(generator, &keyPair);
1806 EXPECT_EQ(res, HCF_SUCCESS);
1807 EXPECT_NE(keyPair, nullptr);
1808
1809 EXPECT_NE(keyPair->pubKey->getAsyKeySpecString, nullptr);
1810
1811 HcfObjDestroy(keyPair);
1812 HcfObjDestroy(generator);
1813 }
1814
1815 // check invalid get key functions of key pair's pri key from key pair spec
1816 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest192, TestSize.Level0)
1817 {
1818 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1819 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1820 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1821 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1822 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1823
1824 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1825 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1826 EXPECT_EQ(res, HCF_SUCCESS);
1827 EXPECT_NE(generator, nullptr);
1828
1829 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1830 HcfKeyPair *keyPair = nullptr;
1831 res = generator->generateKeyPair(generator, &keyPair);
1832 EXPECT_EQ(res, HCF_SUCCESS);
1833 EXPECT_NE(keyPair, nullptr);
1834
1835 EXPECT_NE(keyPair->priKey->getAsyKeySpecInt, nullptr);
1836
1837 keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey);
1838 HcfObjDestroy(keyPair);
1839 HcfObjDestroy(generator);
1840 }
1841
1842 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest193, TestSize.Level0)
1843 {
1844 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1845 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1846 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1847 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1848 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1849
1850 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1851 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1852 EXPECT_EQ(res, HCF_SUCCESS);
1853 EXPECT_NE(generator, nullptr);
1854
1855 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1856 HcfKeyPair *keyPair = nullptr;
1857 res = generator->generateKeyPair(generator, &keyPair);
1858 EXPECT_EQ(res, HCF_SUCCESS);
1859 EXPECT_NE(keyPair, nullptr);
1860
1861 EXPECT_NE(keyPair->priKey->getAsyKeySpecString, nullptr);
1862
1863 keyPair->priKey->clearMem(keyPair->priKey);
1864 HcfObjDestroy(keyPair);
1865 HcfObjDestroy(generator);
1866 }
1867
1868 // check invalid get key functions of pub key from key pair spec
1869 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest194, TestSize.Level0)
1870 {
1871 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1872 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1873 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1874 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1875 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1876
1877 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1878 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1879 EXPECT_EQ(res, HCF_SUCCESS);
1880 EXPECT_NE(generator, nullptr);
1881
1882 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1883 HcfPubKey *pubKey = nullptr;
1884 res = generator->generatePubKey(generator, &pubKey);
1885 EXPECT_EQ(res, HCF_SUCCESS);
1886 EXPECT_NE(pubKey, nullptr);
1887
1888 EXPECT_NE(pubKey->getAsyKeySpecInt, nullptr);
1889
1890 HcfObjDestroy(pubKey);
1891 HcfObjDestroy(generator);
1892 }
1893
1894 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest195, TestSize.Level0)
1895 {
1896 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1897 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1898 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1899 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1900 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1901
1902 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1903 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1904 EXPECT_EQ(res, HCF_SUCCESS);
1905 EXPECT_NE(generator, nullptr);
1906
1907 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1908 HcfPubKey *pubKey = nullptr;
1909 res = generator->generatePubKey(generator, &pubKey);
1910 EXPECT_EQ(res, HCF_SUCCESS);
1911 EXPECT_NE(pubKey, nullptr);
1912
1913 EXPECT_NE(pubKey->getAsyKeySpecString, nullptr);
1914
1915 HcfObjDestroy(pubKey);
1916 HcfObjDestroy(generator);
1917 }
1918
1919 // check invalid get key functions of pri key from key pair spec
1920 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest196, TestSize.Level0)
1921 {
1922 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1923 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1924 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1925 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1926 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1927
1928 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1929 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1930 EXPECT_EQ(res, HCF_SUCCESS);
1931 EXPECT_NE(generator, nullptr);
1932
1933 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1934 HcfPriKey *priKey = nullptr;
1935 res = generator->generatePriKey(generator, &priKey);
1936 EXPECT_EQ(res, HCF_SUCCESS);
1937 EXPECT_NE(priKey, nullptr);
1938
1939 EXPECT_NE(priKey->getAsyKeySpecInt, nullptr);
1940
1941 priKey->clearMem(priKey);
1942 HcfObjDestroy(priKey);
1943 HcfObjDestroy(generator);
1944 }
1945
1946 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest197, TestSize.Level0)
1947 {
1948 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1949 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1950 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1951 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1952 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1953
1954 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1955 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1956 EXPECT_EQ(res, HCF_SUCCESS);
1957 EXPECT_NE(generator, nullptr);
1958
1959 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1960 HcfPriKey *priKey = nullptr;
1961 res = generator->generatePriKey(generator, &priKey);
1962 EXPECT_EQ(res, HCF_SUCCESS);
1963 EXPECT_NE(priKey, nullptr);
1964
1965 EXPECT_NE(priKey->getAsyKeySpecString, nullptr);
1966
1967 priKey->clearMem(priKey);
1968 HcfObjDestroy(priKey);
1969 HcfObjDestroy(generator);
1970 }
1971
1972 // HcfAsyKeyGeneratorCreate correct case: RSA 512 generate keyPair get all big int
1973 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest198, TestSize.Level0)
1974 {
1975 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1976 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
1977 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
1978 unsigned char dataD[RSA_512_D_BYTE_SIZE] = {0};
1979 GenerateRsa512CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1980
1981 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1982 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1983 EXPECT_EQ(res, HCF_SUCCESS);
1984 EXPECT_NE(generator, nullptr);
1985
1986 HcfKeyPair *keyPair = nullptr;
1987 // generator key type from generator's spec
1988 res = generator->generateKeyPair(generator, &keyPair);
1989 EXPECT_EQ(res, HCF_SUCCESS);
1990 EXPECT_NE(keyPair, nullptr);
1991 HcfPriKey *priKey = keyPair->priKey;
1992 HcfPubKey *pubKey = keyPair->pubKey;
1993
1994 HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
1995 HcfBigInteger returnPriN = { .data = nullptr, .len = 0 };
1996 HcfBigInteger returnE = { .data = nullptr, .len = 0 };
1997 HcfBigInteger returnD = { .data = nullptr, .len = 0 };
1998 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &returnPriN);
1999 EXPECT_EQ(res, HCF_SUCCESS);
2000 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &returnD);
2001 EXPECT_EQ(res, HCF_SUCCESS);
2002 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
2003 EXPECT_EQ(res, HCF_SUCCESS);
2004 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
2005 EXPECT_EQ(res, HCF_SUCCESS);
2006
2007 // check the array data
2008 int memRes = 0;
2009 memRes = memcmp(returnPubN.data, dataN, RSA_512_N_BYTE_SIZE);
2010 EXPECT_EQ(memRes, 0);
2011 memRes = memcmp(returnPriN.data, dataN, RSA_512_N_BYTE_SIZE);
2012 EXPECT_EQ(memRes, 0);
2013 memRes = memcmp(returnD.data, dataD, RSA_512_D_BYTE_SIZE);
2014 EXPECT_EQ(memRes, 0);
2015 memRes = memcmp(returnE.data, dataE, RSA_512_E_BYTE_SIZE);
2016 EXPECT_EQ(memRes, 0);
2017
2018 HcfFree(returnPubN.data);
2019 HcfFree(returnPriN.data);
2020 HcfFree(returnD.data);
2021 HcfFree(returnE.data);
2022 HcfObjDestroy(keyPair);
2023 HcfObjDestroy(generator);
2024 }
2025
2026 // HcfAsyKeyGeneratorCreate correct case: RSA 512 generate pub key get
2027 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest199, TestSize.Level0)
2028 {
2029 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
2030 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
2031 unsigned char dataE[RSA_512_E_BYTE_SIZE] = {0};
2032 GenerateRsa512CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
2033 HcfAsyKeyGeneratorBySpec *generator = nullptr;
2034 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
2035 EXPECT_EQ(res, HCF_SUCCESS);
2036 EXPECT_NE(generator, nullptr);
2037
2038 HcfPubKey *pubKey = nullptr;
2039 res = generator->generatePubKey(generator, &pubKey);
2040 EXPECT_EQ(res, HCF_SUCCESS);
2041 EXPECT_NE(pubKey, nullptr);
2042
2043 HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
2044 HcfBigInteger returnE = { .data = nullptr, .len = 0 };
2045 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
2046 EXPECT_EQ(res, HCF_SUCCESS);
2047 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
2048 EXPECT_EQ(res, HCF_SUCCESS);
2049
2050 int memRes = 0;
2051 memRes = memcmp(returnPubN.data, dataN, RSA_512_N_BYTE_SIZE);
2052 EXPECT_EQ(memRes, 0);
2053 memRes = memcmp(returnE.data, dataE, RSA_512_E_BYTE_SIZE);
2054 EXPECT_EQ(memRes, 0);
2055 HcfFree(returnPubN.data);
2056 HcfFree(returnE.data);
2057 HcfObjDestroy(pubKey);
2058 HcfObjDestroy(generator);
2059 }
2060
2061 // HcfAsyKeyGeneratorCreate incorrect case: RSA 512 generate common key spec (not support)
2062 HWTEST_F(CryptoRsa512AsyKeyGeneratorBySpecTest, CryptoRsa512AsyKeyGeneratorBySpecTest200, TestSize.Level0)
2063 {
2064 HcfRsaCommParamsSpec rsaCommSpec = {};
2065
2066 unsigned char dataN[RSA_512_N_BYTE_SIZE] = {0};
2067 GenerateRsa512CorrectCommonKeySpec(dataN, &rsaCommSpec);
2068
2069 HcfAsyKeyGeneratorBySpec *generator = nullptr;
2070 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
2071 EXPECT_NE(res, HCF_SUCCESS);
2072 EXPECT_EQ(generator, nullptr);
2073 HcfObjDestroy(generator);
2074 }
2075 }