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 }