1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <string>
18 #include "securec.h"
19 
20 #include "asy_key_generator.h"
21 #include "sm2_asy_key_generator_openssl.h"
22 #include "ecc_openssl_common.h"
23 #include "ecc_openssl_common_param_spec.h"
24 #include "ecc_common.h"
25 #include "ecc_common_param_spec.h"
26 #include "ecc_key_util.h"
27 #include "key_utils.h"
28 #include "blob.h"
29 #include "cipher.h"
30 #include "cipher_sm2_openssl.h"
31 #include "sm2_openssl.h"
32 #include "signature.h"
33 #include "key_pair.h"
34 #include "memory.h"
35 #include "memory_mock.h"
36 #include "openssl_adapter_mock.h"
37 #include "openssl_class.h"
38 #include "openssl_common.h"
39 #include "params_parser.h"
40 
41 using namespace std;
42 using namespace testing::ext;
43 
44 namespace {
45 constexpr int ZERO = 0;
46 constexpr int ONE = 1;
47 constexpr int TWO = 2;
48 constexpr int THREE = 3;
49 constexpr int FOUR = 4;
50 constexpr int FIVE = 5;
51 constexpr int SIX = 6;
52 constexpr int SEVEN = 7;
53 constexpr int EIGHT = 8;
54 
55 class CryptoSm2AsyKeyGeneratorBySpecSubTest : public testing::Test {
56 public:
SetUpTestCase()57     static void SetUpTestCase(){};
TearDownTestCase()58     static void TearDownTestCase(){};
59     void SetUp();
60     void TearDown();
61 };
62 
SetUp()63 void CryptoSm2AsyKeyGeneratorBySpecSubTest::SetUp() {}
TearDown()64 void CryptoSm2AsyKeyGeneratorBySpecSubTest::TearDown() {}
65 
GetMockClass(void)66 static const char *GetMockClass(void)
67 {
68     return "HcfSymKeyGenerator";
69 }
70 
71 HcfObjectBase g_obj = {
72     .getClass = GetMockClass,
73     .destroy = nullptr
74 };
75 
76 static const char *g_mockMessage = "hello world";
77 static HcfBlob g_mockInput = {
78     .data = (uint8_t *)g_mockMessage,
79     .len = 12
80 };
81 
82 static string g_sm2AlgName = "SM2_256";
83 static string g_sm2CurveName = "NID_sm2";
84 
85 HcfEccCommParamsSpec *g_eccCommSpec = nullptr;
86 
ConstructSm2256CommParamsSpec(HcfAsyKeyParamsSpec ** spec)87 static HcfResult ConstructSm2256CommParamsSpec(HcfAsyKeyParamsSpec **spec)
88 {
89     HcfEccCommParamsSpec *eccCommSpec = nullptr;
90     HcfEccKeyUtilCreate(g_sm2CurveName.c_str(), &eccCommSpec);
91     if (eccCommSpec == nullptr) {
92         return HCF_INVALID_PARAMS;
93     }
94     *spec = (HcfAsyKeyParamsSpec *)eccCommSpec;
95     return HCF_SUCCESS;
96 }
97 
98 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest066, TestSize.Level0)
99 {
100     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
101     ASSERT_NE(g_eccCommSpec, nullptr);
102     HcfAsyKeyParamsSpec *paramSpec = nullptr;
103     HcfResult res = ConstructEccPubKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
104     ASSERT_EQ(res, HCF_SUCCESS);
105     ASSERT_NE(paramSpec, nullptr);
106 
107     HcfAsyKeyGeneratorBySpec *generator = nullptr;
108     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
109     ASSERT_EQ(res, HCF_SUCCESS);
110     ASSERT_NE(generator, nullptr);
111 
112     HcfPubKey *pubKey = nullptr;
113     res = generator->generatePubKey(generator, &pubKey);
114     ASSERT_EQ(res, HCF_SUCCESS);
115     ASSERT_NE(pubKey, nullptr);
116 
117     HcfBlob blob = { .data = nullptr, .len = 0 };
118     res = pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
119     ASSERT_NE(res, HCF_SUCCESS);
120     ASSERT_EQ(blob.data, nullptr);
121     ASSERT_EQ(blob.len, 0);
122 
123     HcfFree(blob.data);
124     HcfObjDestroy(pubKey);
125     HcfObjDestroy(generator);
126     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
127 }
128 
129 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest067, TestSize.Level0)
130 {
131     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
132     ASSERT_NE(g_eccCommSpec, nullptr);
133     HcfAsyKeyParamsSpec *paramSpec = nullptr;
134     HcfResult res = ConstructEccPubKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
135     ASSERT_EQ(res, HCF_SUCCESS);
136     ASSERT_NE(paramSpec, nullptr);
137 
138     HcfAsyKeyGeneratorBySpec *generator = nullptr;
139     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
140     ASSERT_EQ(res, HCF_SUCCESS);
141     ASSERT_NE(generator, nullptr);
142 
143     HcfPubKey *pubKey = nullptr;
144     res = generator->generatePubKey(generator, &pubKey);
145     ASSERT_EQ(res, HCF_SUCCESS);
146     ASSERT_NE(pubKey, nullptr);
147 
148     res = pubKey->base.getEncoded(&(pubKey->base), nullptr);
149     ASSERT_NE(res, HCF_SUCCESS);
150 
151     HcfObjDestroy(pubKey);
152     HcfObjDestroy(generator);
153     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
154 }
155 
156 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest068, TestSize.Level0)
157 {
158     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
159     ASSERT_NE(g_eccCommSpec, nullptr);
160     HcfAsyKeyParamsSpec *paramSpec = nullptr;
161     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
162     ASSERT_EQ(res, HCF_SUCCESS);
163     ASSERT_NE(paramSpec, nullptr);
164 
165     HcfAsyKeyGeneratorBySpec *generator = nullptr;
166     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
167     ASSERT_EQ(res, HCF_SUCCESS);
168     ASSERT_NE(generator, nullptr);
169 
170     HcfPriKey *priKey = nullptr;
171     res = generator->generatePriKey(generator, &priKey);
172     ASSERT_EQ(res, HCF_SUCCESS);
173     ASSERT_NE(priKey, nullptr);
174 
175     HcfObjDestroy(priKey);
176     HcfObjDestroy(generator);
177     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
178 }
179 
180 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest069, TestSize.Level0)
181 {
182     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
183     ASSERT_NE(g_eccCommSpec, nullptr);
184     HcfAsyKeyParamsSpec *paramSpec = nullptr;
185     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
186     ASSERT_EQ(res, HCF_SUCCESS);
187     ASSERT_NE(paramSpec, nullptr);
188 
189     HcfAsyKeyGeneratorBySpec *generator = nullptr;
190     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
191     ASSERT_EQ(res, HCF_SUCCESS);
192     ASSERT_NE(generator, nullptr);
193 
194     HcfPriKey *priKey = nullptr;
195     res = generator->generatePriKey(nullptr, &priKey);
196     ASSERT_NE(res, HCF_SUCCESS);
197     ASSERT_EQ(priKey, nullptr);
198 
199     HcfObjDestroy(priKey);
200     HcfObjDestroy(generator);
201     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
202 }
203 
204 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest070, TestSize.Level0)
205 {
206     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
207     ASSERT_NE(g_eccCommSpec, nullptr);
208     HcfAsyKeyParamsSpec *paramSpec = nullptr;
209     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
210     ASSERT_EQ(res, HCF_SUCCESS);
211     ASSERT_NE(paramSpec, nullptr);
212 
213     HcfAsyKeyGeneratorBySpec *generator = nullptr;
214     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
215     ASSERT_EQ(res, HCF_SUCCESS);
216     ASSERT_NE(generator, nullptr);
217 
218     res = generator->generatePriKey(generator, nullptr);
219     ASSERT_NE(res, HCF_SUCCESS);
220 
221     HcfObjDestroy(generator);
222     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
223 }
224 
225 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest071, TestSize.Level0)
226 {
227     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
228     ASSERT_NE(g_eccCommSpec, nullptr);
229     HcfAsyKeyParamsSpec *paramSpec = nullptr;
230     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
231     ASSERT_EQ(res, HCF_SUCCESS);
232     ASSERT_NE(paramSpec, nullptr);
233 
234     HcfAsyKeyGeneratorBySpec *generator = nullptr;
235     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
236     ASSERT_EQ(res, HCF_SUCCESS);
237     ASSERT_NE(generator, nullptr);
238 
239     res = generator->generatePriKey(nullptr, nullptr);
240     ASSERT_NE(res, HCF_SUCCESS);
241 
242     HcfObjDestroy(generator);
243     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
244 }
245 
246 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest072, TestSize.Level0)
247 {
248     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
249     ASSERT_NE(g_eccCommSpec, nullptr);
250     HcfAsyKeyParamsSpec *paramSpec = nullptr;
251     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
252     ASSERT_EQ(res, HCF_SUCCESS);
253     ASSERT_NE(paramSpec, nullptr);
254 
255     HcfAsyKeyGeneratorBySpec *generator = nullptr;
256     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
257     ASSERT_EQ(res, HCF_SUCCESS);
258     ASSERT_NE(generator, nullptr);
259 
260     HcfPriKey *priKey = nullptr;
261     res = generator->generatePriKey(generator, &priKey);
262     ASSERT_EQ(res, HCF_SUCCESS);
263     ASSERT_NE(priKey, nullptr);
264 
265     const char *className = priKey->base.base.getClass();
266     ASSERT_NE(className, nullptr);
267 
268     HcfObjDestroy(priKey);
269     HcfObjDestroy(generator);
270     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
271 }
272 
273 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest073, TestSize.Level0)
274 {
275     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
276     ASSERT_NE(g_eccCommSpec, nullptr);
277     HcfAsyKeyParamsSpec *paramSpec = nullptr;
278     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
279     ASSERT_EQ(res, HCF_SUCCESS);
280     ASSERT_NE(paramSpec, nullptr);
281 
282     HcfAsyKeyGeneratorBySpec *generator = nullptr;
283     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
284     ASSERT_EQ(res, HCF_SUCCESS);
285     ASSERT_NE(generator, nullptr);
286 
287     HcfPriKey *priKey = nullptr;
288     res = generator->generatePriKey(generator, &priKey);
289     ASSERT_EQ(res, HCF_SUCCESS);
290     ASSERT_NE(priKey, nullptr);
291 
292     priKey->base.base.destroy((HcfObjectBase *)(&(priKey->base.base)));
293     HcfObjDestroy(generator);
294     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
295 }
296 
297 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest074, TestSize.Level0)
298 {
299     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
300     ASSERT_NE(g_eccCommSpec, nullptr);
301     HcfAsyKeyParamsSpec *paramSpec = nullptr;
302     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
303     ASSERT_EQ(res, HCF_SUCCESS);
304     ASSERT_NE(paramSpec, nullptr);
305 
306     HcfAsyKeyGeneratorBySpec *generator = nullptr;
307     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
308     ASSERT_EQ(res, HCF_SUCCESS);
309     ASSERT_NE(generator, nullptr);
310 
311     HcfPriKey *priKey = nullptr;
312     res = generator->generatePriKey(generator, &priKey);
313     ASSERT_EQ(res, HCF_SUCCESS);
314     ASSERT_NE(priKey, nullptr);
315 
316     priKey->base.base.destroy(nullptr);
317     HcfObjDestroy(priKey);
318     HcfObjDestroy(generator);
319     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
320 }
321 
322 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest075, TestSize.Level0)
323 {
324     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
325     ASSERT_NE(g_eccCommSpec, nullptr);
326     HcfAsyKeyParamsSpec *paramSpec = nullptr;
327     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
328     ASSERT_EQ(res, HCF_SUCCESS);
329     ASSERT_NE(paramSpec, nullptr);
330 
331     HcfAsyKeyGeneratorBySpec *generator = nullptr;
332     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
333     ASSERT_EQ(res, HCF_SUCCESS);
334     ASSERT_NE(generator, nullptr);
335 
336     HcfPriKey *priKey = nullptr;
337     res = generator->generatePriKey(generator, &priKey);
338     ASSERT_EQ(res, HCF_SUCCESS);
339     ASSERT_NE(priKey, nullptr);
340 
341     priKey->base.base.destroy(&g_obj);
342     HcfObjDestroy(priKey);
343     HcfObjDestroy(generator);
344     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
345 }
346 
347 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest076, TestSize.Level0)
348 {
349     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
350     ASSERT_NE(g_eccCommSpec, nullptr);
351     HcfAsyKeyParamsSpec *paramSpec = nullptr;
352     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
353     ASSERT_EQ(res, HCF_SUCCESS);
354     ASSERT_NE(paramSpec, nullptr);
355 
356     HcfAsyKeyGeneratorBySpec *generator = nullptr;
357     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
358     ASSERT_EQ(res, HCF_SUCCESS);
359     ASSERT_NE(generator, nullptr);
360 
361     HcfPriKey *priKey = nullptr;
362     res = generator->generatePriKey(generator, &priKey);
363     ASSERT_EQ(res, HCF_SUCCESS);
364     ASSERT_NE(priKey, nullptr);
365 
366     res = priKey->base.getEncoded(&(priKey->base), nullptr);
367     ASSERT_NE(res, HCF_SUCCESS);
368 
369     HcfObjDestroy(priKey);
370     HcfObjDestroy(generator);
371     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
372 }
373 
374 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest077, TestSize.Level0)
375 {
376     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
377     ASSERT_NE(g_eccCommSpec, nullptr);
378     HcfAsyKeyParamsSpec *paramSpec = nullptr;
379     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
380     ASSERT_EQ(res, HCF_SUCCESS);
381     ASSERT_NE(paramSpec, nullptr);
382 
383     HcfAsyKeyGeneratorBySpec *generator = nullptr;
384     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
385     ASSERT_EQ(res, HCF_SUCCESS);
386     ASSERT_NE(generator, nullptr);
387 
388     HcfPriKey *priKey = nullptr;
389     res = generator->generatePriKey(generator, &priKey);
390     ASSERT_EQ(res, HCF_SUCCESS);
391     ASSERT_NE(priKey, nullptr);
392 
393     priKey->clearMem(priKey);
394     HcfObjDestroy(priKey);
395     HcfObjDestroy(generator);
396     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
397 }
398 
399 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest078, TestSize.Level0)
400 {
401     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
402     ASSERT_NE(g_eccCommSpec, nullptr);
403     HcfAsyKeyParamsSpec *paramSpec = nullptr;
404     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
405     ASSERT_EQ(res, HCF_SUCCESS);
406     ASSERT_NE(paramSpec, nullptr);
407 
408     HcfAsyKeyGeneratorBySpec *generator = nullptr;
409     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
410     ASSERT_EQ(res, HCF_SUCCESS);
411     ASSERT_NE(generator, nullptr);
412 
413     HcfPriKey *priKey = nullptr;
414     res = generator->generatePriKey(generator, &priKey);
415     ASSERT_EQ(res, HCF_SUCCESS);
416     ASSERT_NE(priKey, nullptr);
417 
418     priKey->clearMem(nullptr);
419     HcfObjDestroy(priKey);
420     HcfObjDestroy(generator);
421     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
422 }
423 
424 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest079, TestSize.Level0)
425 {
426     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
427     ASSERT_NE(g_eccCommSpec, nullptr);
428     HcfAsyKeyParamsSpec *paramSpec = nullptr;
429     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
430     ASSERT_EQ(res, HCF_SUCCESS);
431     ASSERT_NE(paramSpec, nullptr);
432 
433     HcfAsyKeyGeneratorBySpec *generator = nullptr;
434     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
435     ASSERT_EQ(res, HCF_SUCCESS);
436     ASSERT_NE(generator, nullptr);
437 
438     HcfPriKey *priKey = nullptr;
439     res = generator->generatePriKey(generator, &priKey);
440     ASSERT_EQ(res, HCF_SUCCESS);
441     ASSERT_NE(priKey, nullptr);
442 
443     const char *format = priKey->base.getFormat(&priKey->base);
444     ASSERT_NE(format, nullptr);
445 
446     HcfObjDestroy(priKey);
447     HcfObjDestroy(generator);
448     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
449 }
450 
451 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest080, TestSize.Level0)
452 {
453     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
454     ASSERT_NE(g_eccCommSpec, nullptr);
455     HcfAsyKeyParamsSpec *paramSpec = nullptr;
456     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
457     ASSERT_EQ(res, HCF_SUCCESS);
458     ASSERT_NE(paramSpec, nullptr);
459 
460     HcfAsyKeyGeneratorBySpec *generator = nullptr;
461     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
462     ASSERT_EQ(res, HCF_SUCCESS);
463     ASSERT_NE(generator, nullptr);
464 
465     HcfPriKey *priKey = nullptr;
466     res = generator->generatePriKey(generator, &priKey);
467     ASSERT_EQ(res, HCF_SUCCESS);
468     ASSERT_NE(priKey, nullptr);
469 
470     const char *format = priKey->base.getFormat(nullptr);
471     ASSERT_EQ(format, nullptr);
472 
473     HcfObjDestroy(priKey);
474     HcfObjDestroy(generator);
475     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
476 }
477 
478 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest081, TestSize.Level0)
479 {
480     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
481     ASSERT_NE(g_eccCommSpec, nullptr);
482     HcfAsyKeyParamsSpec *paramSpec = nullptr;
483     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
484     ASSERT_EQ(res, HCF_SUCCESS);
485     ASSERT_NE(paramSpec, nullptr);
486 
487     HcfAsyKeyGeneratorBySpec *generator = nullptr;
488     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
489     ASSERT_EQ(res, HCF_SUCCESS);
490     ASSERT_NE(generator, nullptr);
491 
492     HcfPriKey *priKey = nullptr;
493     res = generator->generatePriKey(generator, &priKey);
494     ASSERT_EQ(res, HCF_SUCCESS);
495     ASSERT_NE(priKey, nullptr);
496 
497     const char *format = priKey->base.getFormat((HcfKey *)&g_obj);
498     ASSERT_EQ(format, nullptr);
499 
500     HcfObjDestroy(priKey);
501     HcfObjDestroy(generator);
502     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
503 }
504 
505 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest082, TestSize.Level0)
506 {
507     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
508     ASSERT_NE(g_eccCommSpec, nullptr);
509     HcfAsyKeyParamsSpec *paramSpec = nullptr;
510     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
511     ASSERT_EQ(res, HCF_SUCCESS);
512     ASSERT_NE(paramSpec, nullptr);
513 
514     HcfAsyKeyGeneratorBySpec *generator = nullptr;
515     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
516     ASSERT_EQ(res, HCF_SUCCESS);
517     ASSERT_NE(generator, nullptr);
518 
519     HcfPriKey *priKey = nullptr;
520     res = generator->generatePriKey(generator, &priKey);
521     ASSERT_EQ(res, HCF_SUCCESS);
522     ASSERT_NE(priKey, nullptr);
523 
524     const char *algName = priKey->base.getAlgorithm(&priKey->base);
525     ASSERT_NE(algName, nullptr);
526 
527     HcfObjDestroy(priKey);
528     HcfObjDestroy(generator);
529     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
530 }
531 
532 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest083, TestSize.Level0)
533 {
534     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
535     ASSERT_NE(g_eccCommSpec, nullptr);
536     HcfAsyKeyParamsSpec *paramSpec = nullptr;
537     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
538     ASSERT_EQ(res, HCF_SUCCESS);
539     ASSERT_NE(paramSpec, nullptr);
540 
541     HcfAsyKeyGeneratorBySpec *generator = nullptr;
542     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
543     ASSERT_EQ(res, HCF_SUCCESS);
544     ASSERT_NE(generator, nullptr);
545 
546     HcfPriKey *priKey = nullptr;
547     res = generator->generatePriKey(generator, &priKey);
548     ASSERT_EQ(res, HCF_SUCCESS);
549     ASSERT_NE(priKey, nullptr);
550 
551     const char *algName = priKey->base.getAlgorithm(nullptr);
552     ASSERT_EQ(algName, nullptr);
553 
554     HcfObjDestroy(priKey);
555     HcfObjDestroy(generator);
556     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
557 }
558 
559 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest084, TestSize.Level0)
560 {
561     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
562     ASSERT_NE(g_eccCommSpec, nullptr);
563     HcfAsyKeyParamsSpec *paramSpec = nullptr;
564     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
565     ASSERT_EQ(res, HCF_SUCCESS);
566     ASSERT_NE(paramSpec, nullptr);
567 
568     HcfAsyKeyGeneratorBySpec *generator = nullptr;
569     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
570     ASSERT_EQ(res, HCF_SUCCESS);
571     ASSERT_NE(generator, nullptr);
572 
573     HcfPriKey *priKey = nullptr;
574     res = generator->generatePriKey(generator, &priKey);
575     ASSERT_EQ(res, HCF_SUCCESS);
576     ASSERT_NE(priKey, nullptr);
577 
578     const char *algName = priKey->base.getAlgorithm((HcfKey *)&g_obj);
579     ASSERT_EQ(algName, nullptr);
580 
581     HcfObjDestroy(priKey);
582     HcfObjDestroy(generator);
583     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
584 }
585 
586 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest085, TestSize.Level0)
587 {
588     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
589     ASSERT_NE(g_eccCommSpec, nullptr);
590     HcfAsyKeyParamsSpec *paramSpec = nullptr;
591     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
592     ASSERT_EQ(res, HCF_SUCCESS);
593     ASSERT_NE(paramSpec, nullptr);
594     HcfAsyKeyGeneratorBySpec *generator = nullptr;
595     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
596     ASSERT_EQ(res, HCF_SUCCESS);
597     ASSERT_NE(generator, nullptr);
598 
599     HcfPriKey *priKey = nullptr;
600     res = generator->generatePriKey(generator, &priKey);
601     ASSERT_EQ(res, HCF_SUCCESS);
602     ASSERT_NE(priKey, nullptr);
603 
604     HcfBlob blob = {.data = nullptr, .len = 0};
605     res = priKey->base.getEncoded(&(priKey->base), &blob);
606     ASSERT_EQ(res, HCF_SUCCESS);
607     ASSERT_NE(blob.data, nullptr);
608     ASSERT_NE(blob.len, 0);
609 
610     HcfFree(blob.data);
611     HcfObjDestroy(priKey);
612     HcfObjDestroy(generator);
613     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
614 }
615 
616 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest086, TestSize.Level0)
617 {
618     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
619     ASSERT_NE(g_eccCommSpec, nullptr);
620     HcfAsyKeyParamsSpec *paramSpec = nullptr;
621     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
622     ASSERT_EQ(res, HCF_SUCCESS);
623     ASSERT_NE(paramSpec, nullptr);
624 
625     HcfAsyKeyGeneratorBySpec *generator = nullptr;
626     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
627     ASSERT_EQ(res, HCF_SUCCESS);
628     ASSERT_NE(generator, nullptr);
629 
630     HcfPriKey *priKey = nullptr;
631     res = generator->generatePriKey(generator, &priKey);
632     ASSERT_EQ(res, HCF_SUCCESS);
633     ASSERT_NE(priKey, nullptr);
634 
635     HcfBlob blob = {.data = nullptr, .len = 0};
636     res = priKey->base.getEncoded(nullptr, &blob);
637 
638     ASSERT_NE(res, HCF_SUCCESS);
639     ASSERT_EQ(blob.data, nullptr);
640     ASSERT_EQ(blob.len, 0);
641 
642     HcfFree(blob.data);
643     HcfObjDestroy(priKey);
644     HcfObjDestroy(generator);
645     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
646 }
647 
648 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest087, TestSize.Level0)
649 {
650     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
651     ASSERT_NE(g_eccCommSpec, nullptr);
652     HcfAsyKeyParamsSpec *paramSpec = nullptr;
653     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
654     ASSERT_EQ(res, HCF_SUCCESS);
655     ASSERT_NE(paramSpec, nullptr);
656 
657     HcfAsyKeyGeneratorBySpec *generator = nullptr;
658     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
659     ASSERT_EQ(res, HCF_SUCCESS);
660     ASSERT_NE(generator, nullptr);
661 
662     HcfPriKey *priKey = nullptr;
663     res = generator->generatePriKey(generator, &priKey);
664     ASSERT_EQ(res, HCF_SUCCESS);
665     ASSERT_NE(priKey, nullptr);
666 
667     HcfBlob blob = {.data = nullptr, .len = 0};
668     res = priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
669     ASSERT_NE(res, HCF_SUCCESS);
670     ASSERT_EQ(blob.data, nullptr);
671     ASSERT_EQ(blob.len, 0);
672 
673     HcfFree(blob.data);
674     HcfObjDestroy(priKey);
675     HcfObjDestroy(generator);
676     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
677 }
678 
679 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest088, TestSize.Level0)
680 {
681     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
682     ASSERT_NE(g_eccCommSpec, nullptr);
683     HcfAsyKeyParamsSpec *paramSpec = nullptr;
684     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
685     ASSERT_EQ(res, HCF_SUCCESS);
686     ASSERT_NE(paramSpec, nullptr);
687 
688     HcfAsyKeyGeneratorBySpec *generator = nullptr;
689     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
690     ASSERT_EQ(res, HCF_SUCCESS);
691     ASSERT_NE(generator, nullptr);
692 
693     HcfPriKey *priKey = nullptr;
694     res = generator->generatePriKey(generator, &priKey);
695     ASSERT_EQ(res, HCF_SUCCESS);
696     ASSERT_NE(priKey, nullptr);
697 
698     res = priKey->base.getEncoded(&(priKey->base), nullptr);
699     ASSERT_NE(res, HCF_SUCCESS);
700 
701     HcfObjDestroy(priKey);
702     HcfObjDestroy(generator);
703     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
704 }
705 
706 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest089, TestSize.Level0)
707 {
708     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
709     ASSERT_NE(g_eccCommSpec, nullptr);
710     HcfAsyKeyParamsSpec *paramSpec = nullptr;
711     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
712     ASSERT_EQ(res, HCF_SUCCESS);
713     ASSERT_NE(paramSpec, nullptr);
714 
715     HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
716     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
717     ASSERT_EQ(res, HCF_SUCCESS);
718     ASSERT_NE(generatorBySpec, nullptr);
719 
720     HcfKeyPair *keyPair = nullptr;
721     res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair);
722     ASSERT_EQ(res, HCF_SUCCESS);
723     ASSERT_NE(keyPair, nullptr);
724 
725     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
726     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
727     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
728     ASSERT_EQ(res, HCF_SUCCESS);
729     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
730     ASSERT_EQ(res, HCF_SUCCESS);
731 
732     HcfAsyKeyGenerator *generator = nullptr;
733     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
734     HcfKeyPair *outKeyPair = nullptr;
735     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
736     ASSERT_EQ(res, HCF_SUCCESS);
737     ASSERT_NE(outKeyPair, nullptr);
738     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
739     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
740     ASSERT_EQ(res, HCF_SUCCESS);
741     ASSERT_NE(outPubKeyBlob.data, nullptr);
742     ASSERT_NE(outPubKeyBlob.len, 0);
743     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
744     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
745     ASSERT_EQ(res, HCF_SUCCESS);
746     ASSERT_NE(outPriKeyBlob.data, nullptr);
747     ASSERT_NE(outPriKeyBlob.len, 0);
748     HcfFree(pubKeyBlob.data);
749     HcfFree(priKeyBlob.data);
750     HcfFree(outPubKeyBlob.data);
751     HcfFree(outPriKeyBlob.data);
752     HcfObjDestroy(keyPair);
753     HcfObjDestroy(outKeyPair);
754     HcfObjDestroy(generator);
755     HcfObjDestroy(generatorBySpec);
756     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
757 }
758 
759 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest090, TestSize.Level0)
760 {
761     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
762     ASSERT_NE(g_eccCommSpec, nullptr);
763     HcfAsyKeyParamsSpec *paramSpec = nullptr;
764     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
765     ASSERT_EQ(res, HCF_SUCCESS);
766     ASSERT_NE(paramSpec, nullptr);
767     HcfAsyKeyGeneratorBySpec *generator = nullptr;
768     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
769     ASSERT_EQ(res, HCF_SUCCESS);
770     ASSERT_NE(generator, nullptr);
771     HcfKeyPair *keyPair = nullptr;
772     res = generator->generateKeyPair(generator, &keyPair);
773     ASSERT_EQ(res, HCF_SUCCESS);
774     ASSERT_NE(keyPair, nullptr);
775 
776     uint8_t plan[] = "this is sm2 cipher test!\0";
777     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
778     HcfBlob encoutput = {.data = nullptr, .len = 0};
779     HcfCipher *cipher = nullptr;
780     res = HcfCipherCreate("SM2|SM3", &cipher);
781     EXPECT_EQ(res, HCF_SUCCESS);
782 
783     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
784     EXPECT_EQ(res, HCF_SUCCESS);
785     res = cipher->doFinal(cipher, &input, &encoutput);
786     EXPECT_EQ(res, HCF_SUCCESS);
787     HcfObjDestroy(cipher);
788 
789     HcfBlob decoutput = {.data = nullptr, .len = 0};
790     cipher = nullptr;
791     res = HcfCipherCreate("SM2|SM3", &cipher);
792     EXPECT_EQ(res, HCF_SUCCESS);
793     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
794     EXPECT_EQ(res, HCF_SUCCESS);
795     res = cipher->doFinal(cipher, &encoutput, &decoutput);
796     EXPECT_EQ(res, HCF_SUCCESS);
797     HcfObjDestroy(cipher);
798     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
799 
800     HcfFree(encoutput.data);
801     HcfFree(decoutput.data);
802 
803     HcfObjDestroy(keyPair);
804     HcfObjDestroy(generator);
805     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
806 }
807 
808 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest091, TestSize.Level0)
809 {
810     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
811     ASSERT_NE(g_eccCommSpec, nullptr);
812     HcfAsyKeyParamsSpec *paramSpec = nullptr;
813     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
814     ASSERT_EQ(res, HCF_SUCCESS);
815     ASSERT_NE(paramSpec, nullptr);
816     HcfAsyKeyGeneratorBySpec *generator = nullptr;
817     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
818     ASSERT_EQ(res, HCF_SUCCESS);
819     ASSERT_NE(generator, nullptr);
820     HcfKeyPair *keyPair = nullptr;
821     res = generator->generateKeyPair(generator, &keyPair);
822     ASSERT_EQ(res, HCF_SUCCESS);
823     ASSERT_NE(keyPair, nullptr);
824 
825     HcfSign *sign = nullptr;
826     res = HcfSignCreate("SM2|SM3", &sign);
827 
828     ASSERT_EQ(res, HCF_SUCCESS);
829     ASSERT_NE(sign, nullptr);
830 
831     res = sign->init(sign, nullptr, keyPair->priKey);
832     ASSERT_EQ(res, HCF_SUCCESS);
833 
834     uint8_t pSourceData[] = "1234567812345678\0";
835     HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
836     res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
837     ASSERT_EQ(res, HCF_SUCCESS);
838 
839     HcfBlob out = { .data = nullptr, .len = 0 };
840     res = sign->sign(sign, &g_mockInput, &out);
841 
842     ASSERT_EQ(res, HCF_SUCCESS);
843     ASSERT_NE(out.data, nullptr);
844     ASSERT_NE(out.len, (const unsigned int)0);
845 
846     HcfVerify *verify = nullptr;
847     res = HcfVerifyCreate("SM2|SM3", &verify);
848 
849     ASSERT_EQ(res, HCF_SUCCESS);
850     ASSERT_NE(verify, nullptr);
851 
852     res = verify->init(verify, nullptr, keyPair->pubKey);
853     ASSERT_EQ(res, HCF_SUCCESS);
854 
855     bool flag = verify->verify(verify, &g_mockInput, &out);
856     ASSERT_EQ(flag, true);
857 
858     HcfFree(out.data);
859     HcfObjDestroy(sign);
860     HcfObjDestroy(verify);
861 
862     HcfObjDestroy(keyPair);
863     HcfObjDestroy(generator);
864     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
865 }
866 
867 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest092, TestSize.Level0)
868 {
869     HcfAsyKeyGenParams params = {
870         .algo = HCF_ALG_SM2,
871         .bits = HCF_ALG_SM2_256,
872         .primes = HCF_OPENSSL_PRIMES_2,
873     };
874 
875     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
876     HcfResult res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
877     ASSERT_EQ(res, HCF_SUCCESS);
878     ASSERT_NE(spiObj, nullptr);
879 
880     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
881     ASSERT_NE(g_eccCommSpec, nullptr);
882     HcfAsyKeyParamsSpec *paramSpec = nullptr;
883     res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
884 
885     ASSERT_EQ(res, HCF_SUCCESS);
886 
887     HcfKeyPair *keyPair = nullptr;
888     res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair);
889     ASSERT_EQ(res, HCF_SUCCESS);
890 
891     HcfObjDestroy(spiObj);
892     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
893 }
894 
895 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest093, TestSize.Level0)
896 {
897     HcfAsyKeyGenParams params = {
898         .algo = HCF_ALG_SM2,
899         .bits = HCF_ALG_SM2_256,
900         .primes = HCF_OPENSSL_PRIMES_2,
901     };
902 
903     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
904     HcfResult res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
905     ASSERT_EQ(res, HCF_SUCCESS);
906     ASSERT_NE(spiObj, nullptr);
907 
908     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
909     ASSERT_NE(g_eccCommSpec, nullptr);
910     HcfAsyKeyParamsSpec *paramSpec = nullptr;
911     res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
912 
913     ASSERT_EQ(res, HCF_SUCCESS);
914 
915     HcfPubKey *pubKey = nullptr;
916     res = spiObj->engineGeneratePubKeyBySpec(spiObj, paramSpec, &pubKey);
917     ASSERT_EQ(res, HCF_SUCCESS);
918 
919     HcfObjDestroy(spiObj);
920     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
921 }
922 
923 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest094, TestSize.Level0)
924 {
925     HcfAsyKeyGenParams params = {
926         .algo = HCF_ALG_SM2,
927         .bits = HCF_ALG_SM2_256,
928         .primes = HCF_OPENSSL_PRIMES_2,
929     };
930 
931     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
932     HcfResult res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
933     ASSERT_EQ(res, HCF_SUCCESS);
934     ASSERT_NE(spiObj, nullptr);
935 
936     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
937     ASSERT_NE(g_eccCommSpec, nullptr);
938     HcfAsyKeyParamsSpec *paramSpec = nullptr;
939     res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
940 
941     ASSERT_EQ(res, HCF_SUCCESS);
942 
943     HcfPriKey *priKey = nullptr;
944     res = spiObj->engineGeneratePriKeyBySpec(spiObj, paramSpec, &priKey);
945     ASSERT_EQ(res, HCF_SUCCESS);
946 
947     HcfObjDestroy(spiObj);
948     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
949 }
950 
951 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest095, TestSize.Level0)
952 {
953     HcfAsyKeyGenParams params = {
954         .algo = HCF_ALG_SM2,
955         .bits = 0,
956         .primes = HCF_OPENSSL_PRIMES_2,
957     };
958 
959     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
960     HcfResult res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
961 
962     ASSERT_EQ(res, HCF_SUCCESS);
963     ASSERT_NE(spiObj, nullptr);
964 
965     HcfAsyKeyParamsSpec *paramSpec = nullptr;
966     res = ConstructSm2256CommParamsSpec(&paramSpec);
967 
968     ASSERT_EQ(res, HCF_SUCCESS);
969 
970     HcfKeyPair *keyPair = nullptr;
971     res = spiObj->engineGenerateKeyPairBySpec(spiObj, paramSpec, &keyPair);
972     ASSERT_EQ(res, HCF_SUCCESS);
973 
974     HcfObjDestroy(spiObj);
975     FreeEccCommParamsSpec(reinterpret_cast<HcfEccCommParamsSpec *>(paramSpec));
976 }
977 
978 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest096, TestSize.Level0)
979 {
980     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
981     ASSERT_NE(g_eccCommSpec, nullptr);
982     HcfAsyKeyParamsSpec *paramSpec = nullptr;
983     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
984 
985     ASSERT_EQ(res, HCF_SUCCESS);
986 
987     HcfAsyKeyGeneratorBySpec *generator = nullptr;
988     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
989 
990     HcfPriKey *priKey = nullptr;
991     res = generator->generatePriKey(generator, &priKey);
992 
993     ASSERT_EQ(res, HCF_SUCCESS);
994     ASSERT_NE(priKey, nullptr);
995 
996     char *retStr = nullptr;
997     AsyKeySpecItem item = ECC_CURVE_NAME_STR;
998 
999     res = priKey->getAsyKeySpecString(priKey, item, &retStr);
1000 
1001     ASSERT_EQ(res, HCF_SUCCESS);
1002     ASSERT_NE(retStr, nullptr);
1003 
1004     HcfFree(retStr);
1005     HcfObjDestroy(priKey);
1006     HcfObjDestroy(generator);
1007     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1008 }
1009 
1010 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest097, TestSize.Level0)
1011 {
1012     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1013     ASSERT_NE(g_eccCommSpec, nullptr);
1014     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1015     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1016 
1017     ASSERT_EQ(res, HCF_SUCCESS);
1018 
1019     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1020     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1021 
1022     HcfPubKey *pubKey = nullptr;
1023     res = generator->generatePubKey(generator, &pubKey);
1024 
1025     ASSERT_EQ(res, HCF_SUCCESS);
1026     ASSERT_NE(pubKey, nullptr);
1027 
1028     res = pubKey->getAsyKeySpecString(pubKey, ECC_CURVE_NAME_STR, nullptr);
1029     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1030     char *retStr = nullptr;
1031     res = pubKey->getAsyKeySpecString(pubKey, ECC_FIELD_SIZE_INT, &retStr);
1032     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1033 
1034     HcfObjDestroy(pubKey);
1035     HcfObjDestroy(generator);
1036     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1037 }
1038 
1039 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest098, TestSize.Level0)
1040 {
1041     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1042     HcfResult res = ConstructSm2256CommParamsSpec(&paramSpec);
1043     ASSERT_EQ(res, HCF_SUCCESS);
1044 
1045     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1046     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1047 
1048     HcfKeyPair *keyPair = nullptr;
1049     res = generator->generateKeyPair(generator, &keyPair);
1050     ASSERT_EQ(res, HCF_SUCCESS);
1051     ASSERT_NE(keyPair, nullptr);
1052 
1053     char *retStr = nullptr;
1054     AsyKeySpecItem item = ECC_FIELD_TYPE_STR;
1055 
1056     res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, item, &retStr);
1057     ASSERT_EQ(res, HCF_SUCCESS);
1058     ASSERT_NE(retStr, nullptr);
1059     retStr = nullptr;
1060     res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, item, &retStr);
1061     ASSERT_EQ(res, HCF_SUCCESS);
1062     ASSERT_NE(retStr, nullptr);
1063     HcfFree(retStr);
1064     HcfObjDestroy(keyPair);
1065     HcfObjDestroy(generator);
1066     FreeEccCommParamsSpec(reinterpret_cast<HcfEccCommParamsSpec *>(paramSpec));
1067 }
1068 
1069 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest099, TestSize.Level0)
1070 {
1071     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1072     HcfResult res = ConstructSm2256CommParamsSpec(&paramSpec);
1073     ASSERT_EQ(res, HCF_SUCCESS);
1074 
1075     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1076     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1077 
1078     HcfKeyPair *keyPair = nullptr;
1079     res = generator->generateKeyPair(generator, &keyPair);
1080     ASSERT_EQ(res, HCF_SUCCESS);
1081     ASSERT_NE(keyPair, nullptr);
1082 
1083     AsyKeySpecItem item = ECC_FIELD_TYPE_STR;
1084 
1085     res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, item, nullptr);
1086     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1087 
1088     HcfObjDestroy(keyPair);
1089     HcfObjDestroy(generator);
1090     FreeEccCommParamsSpec(reinterpret_cast<HcfEccCommParamsSpec *>(paramSpec));
1091 }
1092 
1093 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest100, TestSize.Level0)
1094 {
1095     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1096     ASSERT_NE(g_eccCommSpec, nullptr);
1097     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1098     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1099 
1100     ASSERT_EQ(res, HCF_SUCCESS);
1101 
1102     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1103     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1104 
1105     HcfKeyPair *keyPair = nullptr;
1106     res = generator->generateKeyPair(generator, &keyPair);
1107 
1108     ASSERT_EQ(res, HCF_SUCCESS);
1109     ASSERT_NE(keyPair, nullptr);
1110 
1111     int retInt = 0;
1112     AsyKeySpecItem item = ECC_FIELD_SIZE_INT;
1113     res = keyPair->pubKey->getAsyKeySpecInt(keyPair->pubKey, item, &retInt);
1114     ASSERT_EQ(res, HCF_SUCCESS);
1115     ASSERT_NE(retInt, 0);
1116     retInt = 0;
1117     res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, item, &retInt);
1118 
1119     ASSERT_EQ(res, HCF_SUCCESS);
1120     ASSERT_NE(retInt, 0);
1121 
1122     HcfObjDestroy(keyPair);
1123     HcfObjDestroy(generator);
1124     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1125 }
1126 
1127 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest101, TestSize.Level0)
1128 {
1129     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1130     ASSERT_NE(g_eccCommSpec, nullptr);
1131     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1132     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1133 
1134     ASSERT_EQ(res, HCF_SUCCESS);
1135 
1136     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1137     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1138 
1139     HcfKeyPair *keyPair = nullptr;
1140     res = generator->generateKeyPair(generator, &keyPair);
1141 
1142     ASSERT_EQ(res, HCF_SUCCESS);
1143     ASSERT_NE(keyPair, nullptr);
1144 
1145     res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, ECC_FIELD_SIZE_INT, nullptr);
1146     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1147     int retInt = 0;
1148     res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, ECC_FIELD_TYPE_STR, &retInt);
1149     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1150     HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
1151     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, nullptr);
1152     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1153     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_SK_BN, &retBigInt);
1154     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1155     HcfObjDestroy(keyPair);
1156     HcfObjDestroy(generator);
1157     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1158 }
1159 
ConstructSm2256KeyPairParamsSpecByGet(HcfEccKeyPairParamsSpec * eccKeyPairSpec,HcfBigInteger * params,int h)1160 static HcfResult ConstructSm2256KeyPairParamsSpecByGet(HcfEccKeyPairParamsSpec *eccKeyPairSpec,
1161     HcfBigInteger *params, int h)
1162 {
1163     eccKeyPairSpec->base.base.algName = g_eccCommSpec->base.algName;
1164     eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
1165     eccKeyPairSpec->base.field = g_eccCommSpec->field;
1166     eccKeyPairSpec->base.field->fieldType = g_eccCommSpec->field->fieldType;
1167     ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data = params[ZERO].data;
1168     ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = params[ZERO].len;
1169     eccKeyPairSpec->base.a.data = params[ONE].data;
1170     eccKeyPairSpec->base.a.len = params[ONE].len;
1171     eccKeyPairSpec->base.b.data = params[TWO].data;
1172     eccKeyPairSpec->base.b.len = params[TWO].len;
1173     eccKeyPairSpec->base.g.x.data = params[THREE].data;
1174     eccKeyPairSpec->base.g.x.len = params[THREE].len;
1175     eccKeyPairSpec->base.g.y.data = params[FOUR].data;
1176     eccKeyPairSpec->base.g.y.len = params[FOUR].len;
1177 
1178     eccKeyPairSpec->base.n.data = params[FIVE].data;
1179     eccKeyPairSpec->base.n.len = params[FIVE].len;
1180     eccKeyPairSpec->base.h = h;
1181     eccKeyPairSpec->pk.x.data = params[SIX].data;
1182     eccKeyPairSpec->pk.x.len = params[SIX].len;
1183     eccKeyPairSpec->pk.y.data = params[SEVEN].data;
1184     eccKeyPairSpec->pk.y.len = params[SEVEN].len;
1185 
1186     eccKeyPairSpec->sk.data = params[EIGHT].data;
1187     eccKeyPairSpec->sk.len = params[EIGHT].len;
1188     return HCF_SUCCESS;
1189 }
1190 
GetParams(HcfPriKey * priKey,HcfPubKey * pubKey,HcfBigInteger * params,int * retH)1191 static void GetParams(HcfPriKey *priKey, HcfPubKey *pubKey, HcfBigInteger *params, int *retH)
1192 {
1193     HcfBigInteger retFp = { .data = nullptr, .len = 0 };
1194     HcfBigInteger retA = { .data = nullptr, .len = 0 };
1195     HcfBigInteger retB = { .data = nullptr, .len = 0 };
1196     HcfBigInteger retGX = { .data = nullptr, .len = 0 };
1197     HcfBigInteger retGY = { .data = nullptr, .len = 0 };
1198     HcfBigInteger retN = { .data = nullptr, .len = 0 };
1199     HcfBigInteger retSk = { .data = nullptr, .len = 0 };
1200     HcfBigInteger retPkX = { .data = nullptr, .len = 0 };
1201     HcfBigInteger retPkY = { .data = nullptr, .len = 0 };
1202     HcfResult res = priKey->getAsyKeySpecBigInteger(priKey, ECC_FP_P_BN, &retFp);
1203     EXPECT_EQ(res, HCF_SUCCESS);
1204     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_A_BN, &retA);
1205     EXPECT_EQ(res, HCF_SUCCESS);
1206     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_B_BN, &retB);
1207     EXPECT_EQ(res, HCF_SUCCESS);
1208     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_G_X_BN, &retGX);
1209     EXPECT_EQ(res, HCF_SUCCESS);
1210     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_G_Y_BN, &retGY);
1211     EXPECT_EQ(res, HCF_SUCCESS);
1212     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_N_BN, &retN);
1213     EXPECT_EQ(res, HCF_SUCCESS);
1214     res = pubKey->getAsyKeySpecBigInteger(pubKey, ECC_PK_X_BN, &retPkX);
1215     EXPECT_EQ(res, HCF_SUCCESS);
1216     res = pubKey->getAsyKeySpecBigInteger(pubKey, ECC_PK_Y_BN, &retPkY);
1217     EXPECT_EQ(res, HCF_SUCCESS);
1218     res = priKey->getAsyKeySpecBigInteger(priKey, ECC_SK_BN, &retSk);
1219     EXPECT_EQ(res, HCF_SUCCESS);
1220     res = pubKey->getAsyKeySpecInt(pubKey, ECC_H_INT, retH);
1221     EXPECT_EQ(res, HCF_SUCCESS);
1222     params[ZERO].data = retFp.data;
1223     params[ZERO].len = retFp.len;
1224     params[ONE].data = retA.data;
1225     params[ONE].len = retA.len;
1226     params[TWO].data = retB.data;
1227     params[TWO].len = retB.len;
1228     params[THREE].data = retGX.data;
1229     params[THREE].len = retGX.len;
1230     params[FOUR].data = retGY.data;
1231     params[FOUR].len = retGY.len;
1232     params[FIVE].data = retN.data;
1233     params[FIVE].len = retN.len;
1234     params[SIX].data = retPkX.data;
1235     params[SIX].len = retPkX.len;
1236     params[SEVEN].data = retPkY.data;
1237     params[SEVEN].len = retPkY.len;
1238     params[EIGHT].data = retSk.data;
1239     params[EIGHT].len = retSk.len;
1240 }
1241 
1242 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest102, TestSize.Level0)
1243 {
1244     HcfAsyKeyGenerator *generator = nullptr;
1245     HcfResult res = HcfAsyKeyGeneratorCreate(g_sm2AlgName.c_str(), &generator);
1246 
1247     HcfKeyPair *keyPair = nullptr;
1248     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1249 
1250     EXPECT_EQ(res, HCF_SUCCESS);
1251     EXPECT_NE(keyPair, nullptr);
1252 
1253     int retH = 0;
1254     HcfBigInteger params[9];
1255     GetParams(keyPair->priKey, keyPair->pubKey, params, &retH);
1256 
1257     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1258     ASSERT_NE(g_eccCommSpec, nullptr);
1259     HcfEccKeyPairParamsSpec eccKeyPairSpec = {};
1260     res = ConstructSm2256KeyPairParamsSpecByGet(&eccKeyPairSpec, params, retH);
1261     HcfAsyKeyGeneratorBySpec *generatorSpec = nullptr;
1262     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&eccKeyPairSpec), &generatorSpec);
1263     EXPECT_EQ(res, HCF_SUCCESS);
1264     EXPECT_NE(generatorSpec, nullptr);
1265 
1266     HcfKeyPair *dupKeyPair = nullptr;
1267     res = generatorSpec->generateKeyPair(generatorSpec, &dupKeyPair);
1268     EXPECT_EQ(res, HCF_SUCCESS);
1269     EXPECT_NE(dupKeyPair, nullptr);
1270 
1271     HcfObjDestroy(dupKeyPair);
1272     HcfObjDestroy(keyPair);
1273     HcfObjDestroy(generator);
1274     HcfObjDestroy(generatorSpec);
1275     FreeEccCommParamsSpec(reinterpret_cast<HcfEccCommParamsSpec *>(g_eccCommSpec));
1276 }
1277 
OpensslMockTestFunc(uint32_t mallocCount,HcfAsyKeyParamsSpec * paramSpec)1278 static void OpensslMockTestFunc(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec)
1279 {
1280     for (uint32_t i = 0; i < mallocCount - THREE; i++) {
1281         ResetOpensslCallNum();
1282         SetOpensslCallMockIndex(i);
1283 
1284         HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1285         HcfResult res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1286         if (res != HCF_SUCCESS) {
1287             continue;
1288         }
1289         HcfKeyPair *keyPair = nullptr;
1290         res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair);
1291         if (res != HCF_SUCCESS) {
1292             HcfObjDestroy(generatorBySpec);
1293             continue;
1294         }
1295         HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1296         res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1297         if (res != HCF_SUCCESS) {
1298             HcfObjDestroy(keyPair);
1299             HcfObjDestroy(generatorBySpec);
1300             continue;
1301         }
1302         HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1303         res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1304         if (res != HCF_SUCCESS) {
1305             HcfFree(pubKeyBlob.data);
1306             HcfObjDestroy(keyPair);
1307             HcfObjDestroy(generatorBySpec);
1308             continue;
1309         }
1310         HcfFree(pubKeyBlob.data);
1311         HcfFree(priKeyBlob.data);
1312         HcfObjDestroy(keyPair);
1313         HcfObjDestroy(generatorBySpec);
1314     }
1315 }
1316 
1317 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest103, TestSize.Level0)
1318 {
1319     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1320     ASSERT_NE(g_eccCommSpec, nullptr);
1321     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1322     HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1323 
1324     ASSERT_EQ(res, HCF_SUCCESS);
1325     ASSERT_NE(paramSpec, nullptr);
1326 
1327     StartRecordOpensslCallNum();
1328     HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1329     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1330 
1331     ASSERT_EQ(res, HCF_SUCCESS);
1332     ASSERT_NE(generatorBySpec, nullptr);
1333 
1334     HcfKeyPair *keyPair = nullptr;
1335     res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair);
1336 
1337     ASSERT_EQ(res, HCF_SUCCESS);
1338     ASSERT_NE(keyPair, nullptr);
1339 
1340     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1341     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1342 
1343     ASSERT_EQ(res, HCF_SUCCESS);
1344     ASSERT_NE(pubKeyBlob.data, nullptr);
1345     ASSERT_NE(pubKeyBlob.len, 0);
1346 
1347     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1348     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1349 
1350     ASSERT_EQ(res, HCF_SUCCESS);
1351     ASSERT_NE(priKeyBlob.data, nullptr);
1352     ASSERT_NE(priKeyBlob.len, 0);
1353 
1354     HcfFree(pubKeyBlob.data);
1355     HcfFree(priKeyBlob.data);
1356     HcfObjDestroy(keyPair);
1357     HcfObjDestroy(generatorBySpec);
1358 
1359     uint32_t mallocCount = GetOpensslCallNum();
1360     OpensslMockTestFunc(mallocCount, paramSpec);
1361     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1362 
1363     EndRecordOpensslCallNum();
1364 }
1365 
OpensslMockTestFunc1(uint32_t mallocCount,HcfAsyKeyParamsSpec * paramSpec)1366 static void OpensslMockTestFunc1(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec)
1367 {
1368     for (uint32_t i = 0; i < mallocCount - 1; i++) {
1369         ResetOpensslCallNum();
1370         SetOpensslCallMockIndex(i);
1371 
1372         HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1373         HcfResult res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1374         if (res != HCF_SUCCESS) {
1375             continue;
1376         }
1377         HcfKeyPair *keyPair = nullptr;
1378         res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair);
1379         if (res != HCF_SUCCESS) {
1380             HcfObjDestroy(generatorBySpec);
1381             continue;
1382         }
1383         HcfObjDestroy(keyPair);
1384         HcfObjDestroy(generatorBySpec);
1385     }
1386 }
1387 
1388 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest104, TestSize.Level0)
1389 {
1390     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1391     HcfResult res = ConstructSm2256CommParamsSpec(&paramSpec);
1392     ASSERT_EQ(res, HCF_SUCCESS);
1393     ASSERT_NE(paramSpec, nullptr);
1394 
1395     StartRecordOpensslCallNum();
1396     HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1397     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1398     ASSERT_EQ(res, HCF_SUCCESS);
1399     ASSERT_NE(generatorBySpec, nullptr);
1400 
1401     HcfKeyPair *keyPair = nullptr;
1402     res = generatorBySpec->generateKeyPair(generatorBySpec, &keyPair);
1403 
1404     ASSERT_EQ(res, HCF_SUCCESS);
1405     ASSERT_NE(keyPair, nullptr);
1406 
1407     HcfObjDestroy(keyPair);
1408     HcfObjDestroy(generatorBySpec);
1409 
1410     uint32_t mallocCount = GetOpensslCallNum();
1411     OpensslMockTestFunc1(mallocCount, paramSpec);
1412     FreeEccCommParamsSpec(reinterpret_cast<HcfEccCommParamsSpec *>(paramSpec));
1413 
1414     EndRecordOpensslCallNum();
1415 }
1416 
OpensslMockTestFunc2(uint32_t mallocCount,HcfAsyKeyParamsSpec * paramSpec)1417 static void OpensslMockTestFunc2(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec)
1418 {
1419     for (uint32_t i = 0; i < mallocCount - FIVE; i++) {
1420         ResetOpensslCallNum();
1421         SetOpensslCallMockIndex(i);
1422 
1423         HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1424         HcfResult res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1425         if (res != HCF_SUCCESS) {
1426             continue;
1427         }
1428         HcfPriKey *priKey = nullptr;
1429         res = generatorBySpec->generatePriKey(generatorBySpec, &priKey);
1430         if (res != HCF_SUCCESS) {
1431             HcfObjDestroy(generatorBySpec);
1432             continue;
1433         }
1434         HcfObjDestroy(priKey);
1435         HcfObjDestroy(generatorBySpec);
1436     }
1437 }
1438 
1439 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest105, TestSize.Level0)
1440 {
1441     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1442     ASSERT_NE(g_eccCommSpec, nullptr);
1443     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1444     HcfResult res = ConstructEccPriKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1445     ASSERT_EQ(res, HCF_SUCCESS);
1446     ASSERT_NE(paramSpec, nullptr);
1447 
1448     StartRecordOpensslCallNum();
1449     HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1450     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1451     ASSERT_EQ(res, HCF_SUCCESS);
1452     ASSERT_NE(generatorBySpec, nullptr);
1453 
1454     HcfPriKey *priKey = nullptr;
1455     res = generatorBySpec->generatePriKey(generatorBySpec, &priKey);
1456     ASSERT_EQ(res, HCF_SUCCESS);
1457     ASSERT_NE(priKey, nullptr);
1458 
1459     HcfObjDestroy(priKey);
1460     HcfObjDestroy(generatorBySpec);
1461 
1462     uint32_t mallocCount = GetOpensslCallNum();
1463     OpensslMockTestFunc2(mallocCount, paramSpec);
1464     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1465 
1466     EndRecordOpensslCallNum();
1467 }
1468 
OpensslMockTestFunc3(uint32_t mallocCount,HcfAsyKeyParamsSpec * paramSpec)1469 static void OpensslMockTestFunc3(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec)
1470 {
1471     for (uint32_t i = 0; i < mallocCount - 1; i++) {
1472         ResetOpensslCallNum();
1473         SetOpensslCallMockIndex(i);
1474 
1475         HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1476         HcfResult res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1477         if (res != HCF_SUCCESS) {
1478             continue;
1479         }
1480         HcfPubKey *pubKey = nullptr;
1481         res = generatorBySpec->generatePubKey(generatorBySpec, &pubKey);
1482         if (res != HCF_SUCCESS) {
1483             HcfObjDestroy(generatorBySpec);
1484             continue;
1485         }
1486         HcfObjDestroy(pubKey);
1487         HcfObjDestroy(generatorBySpec);
1488     }
1489 }
1490 
1491 HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest106, TestSize.Level0)
1492 {
1493     ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec);
1494     ASSERT_NE(g_eccCommSpec, nullptr);
1495     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1496     HcfResult res = ConstructEccPubKeyParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, &paramSpec);
1497 
1498     ASSERT_EQ(res, HCF_SUCCESS);
1499     ASSERT_NE(paramSpec, nullptr);
1500 
1501     StartRecordOpensslCallNum();
1502     HcfAsyKeyGeneratorBySpec *generatorBySpec = nullptr;
1503     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generatorBySpec);
1504 
1505     ASSERT_EQ(res, HCF_SUCCESS);
1506     ASSERT_NE(generatorBySpec, nullptr);
1507 
1508     HcfPubKey *pubKey = nullptr;
1509     res = generatorBySpec->generatePubKey(generatorBySpec, &pubKey);
1510 
1511     ASSERT_EQ(res, HCF_SUCCESS);
1512     ASSERT_NE(pubKey, nullptr);
1513 
1514     HcfObjDestroy(pubKey);
1515     HcfObjDestroy(generatorBySpec);
1516 
1517     uint32_t mallocCount = GetOpensslCallNum();
1518     OpensslMockTestFunc3(mallocCount, paramSpec);
1519     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1520 
1521     EndRecordOpensslCallNum();
1522 }
1523 }
1524