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 "securec.h"
18 #include "asy_key_generator.h"
19 #include "cipher.h"
20 #include "cipher_sm2_openssl.h"
21 #include "key_pair.h"
22 #include "memory.h"
23 #include "cstring"
24 #include "openssl_common.h"
25 
26 using namespace std;
27 using namespace testing::ext;
28 
29 namespace {
30 class CryptoSm2CipherTest : public testing::Test {
31 public:
32     static void SetUpTestCase();
33     static void TearDownTestCase();
34     void SetUp();
35     void TearDown();
36 
37     static HcfKeyPair *sm2256KeyPair_;
38 };
39 
40 HcfKeyPair *CryptoSm2CipherTest::sm2256KeyPair_ = nullptr;
41 
SetUpTestCase()42 void CryptoSm2CipherTest::SetUpTestCase()
43 {
44     HcfAsyKeyGenerator *generator = nullptr;
45     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
46     ASSERT_EQ(res, HCF_SUCCESS);
47     ASSERT_NE(generator, nullptr);
48 
49     HcfKeyPair *keyPair = nullptr;
50     res = generator->generateKeyPair(generator, nullptr, &keyPair);
51     ASSERT_EQ(res, HCF_SUCCESS);
52     ASSERT_NE(keyPair, nullptr);
53 
54     sm2256KeyPair_ = keyPair;
55 
56     HcfObjDestroy(generator);
57 }
58 
TearDownTestCase()59 void CryptoSm2CipherTest::TearDownTestCase()
60 {
61     HcfObjDestroy(sm2256KeyPair_);
62 }
63 
SetUp()64 void CryptoSm2CipherTest::SetUp() {}
TearDown()65 void CryptoSm2CipherTest::TearDown() {}
66 
GetMockClass(void)67 static const char *GetMockClass(void)
68 {
69     return "HcfMock";
70 }
71 
72 static HcfObjectBase obj = {
73     .getClass = GetMockClass,
74     .destroy = nullptr
75 };
76 
77 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest001, TestSize.Level0)
78 {
79     HcfResult res = HCF_SUCCESS;
80     HcfCipher *cipher = nullptr;
81     res = HcfCipherCreate("SM2|SM3", &cipher);
82     EXPECT_EQ(res, HCF_SUCCESS);
83     EXPECT_NE(cipher, nullptr);
84     EXPECT_NE(cipher->base.getClass(), nullptr);
85     EXPECT_NE(cipher->base.destroy, nullptr);
86     EXPECT_NE(cipher->init, nullptr);
87     EXPECT_NE(cipher->update, nullptr);
88     EXPECT_NE(cipher->doFinal, nullptr);
89     EXPECT_NE(cipher->getAlgorithm, nullptr);
90     HcfObjDestroy(cipher);
91 }
92 
93 // HcfCipherCreate Incorrect case
94 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest002, TestSize.Level0)
95 {
96     HcfResult res = HCF_SUCCESS;
97     res = HcfCipherCreate("SM2|SM3", nullptr);
98     EXPECT_NE(res, HCF_SUCCESS);
99 }
100 
101 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest003, TestSize.Level0)
102 {
103     HcfResult res = HCF_SUCCESS;
104     HcfCipher *cipher = nullptr;
105     res = HcfCipherCreate(nullptr, &cipher);
106     EXPECT_NE(res, HCF_SUCCESS);
107     EXPECT_EQ(cipher, nullptr);
108 }
109 
110 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest004, TestSize.Level0)
111 {
112     HcfResult res = HCF_SUCCESS;
113     HcfCipher *cipher = nullptr;
114     res = HcfCipherCreate("SM2|2111111111111111111111111111111111111111111111"
115         "111111111111123123", &cipher);
116     EXPECT_NE(res, HCF_SUCCESS);
117     EXPECT_EQ(cipher, nullptr);
118 }
119 
120 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest005, TestSize.Level0)
121 {
122     HcfResult res = HCF_SUCCESS;
123     HcfCipher *cipher = nullptr;
124     res = HcfCipherCreate("SM222", &cipher);
125     EXPECT_NE(res, HCF_SUCCESS);
126     EXPECT_EQ(cipher, nullptr);
127 }
128 
129 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest006, TestSize.Level0)
130 {
131     HcfResult res = HCF_SUCCESS;
132     HcfCipher *cipher = nullptr;
133     res = HcfCipherCreate("SM2|SM5", &cipher);
134     EXPECT_NE(res, HCF_SUCCESS);
135     EXPECT_EQ(cipher, nullptr);
136 }
137 
138 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest007, TestSize.Level0)
139 {
140     HcfResult res = HCF_SUCCESS;
141     HcfAsyKeyGenerator *generator = nullptr;
142     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
143     EXPECT_EQ(res, HCF_SUCCESS);
144     HcfKeyPair *keyPair = nullptr;
145     res = generator->generateKeyPair(generator, nullptr, &keyPair);
146     EXPECT_EQ(res, HCF_SUCCESS);
147 
148     HcfCipher *cipher = nullptr;
149     res = HcfCipherCreate("SM2|SM3", &cipher);
150     EXPECT_EQ(res, HCF_SUCCESS);
151     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
152     EXPECT_EQ(res, HCF_SUCCESS);
153 
154     HcfObjDestroy(keyPair);
155     HcfObjDestroy(generator);
156     HcfObjDestroy(cipher);
157 }
158 
159 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest008, TestSize.Level0)
160 {
161     HcfResult res = HCF_SUCCESS;
162     HcfAsyKeyGenerator *generator = nullptr;
163     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
164     EXPECT_EQ(res, HCF_SUCCESS);
165     HcfKeyPair *keyPair = nullptr;
166     res = generator->generateKeyPair(generator, nullptr, &keyPair);
167     EXPECT_EQ(res, HCF_SUCCESS);
168 
169     HcfCipher *cipher = nullptr;
170     res = HcfCipherCreate("SM2|SM3", &cipher);
171     EXPECT_EQ(res, HCF_SUCCESS);
172     res = cipher->init(cipher, (enum HcfCryptoMode)123, (HcfKey *)keyPair->pubKey, nullptr);
173     EXPECT_NE(res, HCF_SUCCESS);
174 
175     HcfObjDestroy(keyPair);
176     HcfObjDestroy(generator);
177     HcfObjDestroy(cipher);
178 }
179 
180 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest009, TestSize.Level0)
181 {
182     HcfResult res = HCF_SUCCESS;
183     HcfAsyKeyGenerator *generator = nullptr;
184     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
185     EXPECT_EQ(res, HCF_SUCCESS);
186     HcfKeyPair *keyPair = nullptr;
187     res = generator->generateKeyPair(generator, nullptr, &keyPair);
188     EXPECT_EQ(res, HCF_SUCCESS);
189 
190     HcfCipher *cipher = nullptr;
191     res = HcfCipherCreate("SM2|SM3", &cipher);
192     EXPECT_EQ(res, HCF_SUCCESS);
193     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
194     EXPECT_EQ(res, HCF_SUCCESS);
195 
196     HcfObjDestroy(keyPair);
197     HcfObjDestroy(generator);
198     HcfObjDestroy(cipher);
199 }
200 
201 // init incorrect case
202 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest010, TestSize.Level0)
203 {
204     HcfResult res = HCF_SUCCESS;
205     HcfAsyKeyGenerator *generator = nullptr;
206     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
207     EXPECT_EQ(res, HCF_SUCCESS);
208     HcfKeyPair *keyPair = nullptr;
209     res = generator->generateKeyPair(generator, nullptr, &keyPair);
210     EXPECT_EQ(res, HCF_SUCCESS);
211 
212     HcfCipher *cipher = nullptr;
213     res = HcfCipherCreate("SM2|SM3", &cipher);
214     EXPECT_EQ(res, HCF_SUCCESS);
215     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
216     EXPECT_NE(res, HCF_SUCCESS);
217 
218     HcfObjDestroy(keyPair);
219     HcfObjDestroy(generator);
220     HcfObjDestroy(cipher);
221 }
222 
223 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest011, TestSize.Level0)
224 {
225     HcfResult res = HCF_SUCCESS;
226     HcfAsyKeyGenerator *generator = nullptr;
227     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
228     EXPECT_EQ(res, HCF_SUCCESS);
229     HcfKeyPair *keyPair = nullptr;
230     res = generator->generateKeyPair(generator, nullptr, &keyPair);
231     EXPECT_EQ(res, HCF_SUCCESS);
232 
233     HcfCipher *cipher = nullptr;
234     res = HcfCipherCreate("SM2|SM3", &cipher);
235     EXPECT_EQ(res, HCF_SUCCESS);
236     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
237     EXPECT_NE(res, HCF_SUCCESS);
238 
239     HcfObjDestroy(keyPair);
240     HcfObjDestroy(generator);
241     HcfObjDestroy(cipher);
242 }
243 
244 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest012, TestSize.Level0)
245 {
246     HcfResult res = HCF_SUCCESS;
247     HcfAsyKeyGenerator *generator = nullptr;
248     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
249     EXPECT_EQ(res, HCF_SUCCESS);
250     HcfKeyPair *keyPair = nullptr;
251     res = generator->generateKeyPair(generator, nullptr, &keyPair);
252     EXPECT_EQ(res, HCF_SUCCESS);
253 
254     HcfCipher *cipher = nullptr;
255     res = HcfCipherCreate("SM2|SM3", &cipher);
256     EXPECT_EQ(res, HCF_SUCCESS);
257     res = cipher->init(nullptr, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
258     EXPECT_NE(res, HCF_SUCCESS);
259 
260     HcfObjDestroy(keyPair);
261     HcfObjDestroy(generator);
262     HcfObjDestroy(cipher);
263 }
264 
265 // incorrect case: use diff class, we ignore it in this version
266 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest013, TestSize.Level0)
267 {
268     HcfResult res = HCF_SUCCESS;
269     HcfAsyKeyGenerator *generator = nullptr;
270     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
271     EXPECT_EQ(res, HCF_SUCCESS);
272     HcfKeyPair *keyPair = nullptr;
273     res = generator->generateKeyPair(generator, nullptr, &keyPair);
274     EXPECT_EQ(res, HCF_SUCCESS);
275 
276     HcfCipher *aesCipher = nullptr;
277     res = HcfCipherCreate("AES128|ECB|PKCS7", &aesCipher);
278     EXPECT_EQ(res, HCF_SUCCESS);
279 
280     HcfCipher *cipher = nullptr;
281     res = HcfCipherCreate("SM2|SM3", &cipher);
282     EXPECT_EQ(res, HCF_SUCCESS);
283     res = cipher->init(aesCipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
284     EXPECT_NE(res, HCF_SUCCESS);
285 
286     HcfObjDestroy(keyPair);
287     HcfObjDestroy(generator);
288     HcfObjDestroy(cipher);
289     HcfObjDestroy(aesCipher);
290 }
291 
292 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest014, TestSize.Level0)
293 {
294     HcfResult res = HCF_SUCCESS;
295     HcfCipher *cipher = nullptr;
296     res = HcfCipherCreate("SM2|SM3", &cipher);
297     EXPECT_EQ(res, HCF_SUCCESS);
298     res = cipher->init(cipher, DECRYPT_MODE, nullptr, nullptr);
299     EXPECT_NE(res, HCF_SUCCESS);
300     HcfObjDestroy(cipher);
301 }
302 
303 // correct case: update not support
304 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest015, TestSize.Level0)
305 {
306     uint8_t plan[] = "this is sm2 cipher test!\0";
307     HcfResult res = HCF_SUCCESS;
308     HcfAsyKeyGenerator *generator = nullptr;
309     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
310     EXPECT_EQ(res, HCF_SUCCESS);
311     HcfKeyPair *keyPair = nullptr;
312     res = generator->generateKeyPair(generator, nullptr, &keyPair);
313     EXPECT_EQ(res, HCF_SUCCESS);
314 
315     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
316     HcfBlob encoutput = {.data = nullptr, .len = 0};
317     HcfCipher *cipher = nullptr;
318     res = HcfCipherCreate("SM2|SM3", &cipher);
319     EXPECT_EQ(res, HCF_SUCCESS);
320     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
321     EXPECT_EQ(res, HCF_SUCCESS);
322     res = cipher->update(cipher, &input, &encoutput);
323     EXPECT_NE(res, HCF_SUCCESS);
324     EXPECT_EQ(encoutput.data, nullptr);
325 
326     HcfObjDestroy(keyPair);
327     HcfObjDestroy(generator);
328     HcfObjDestroy(cipher);
329 }
330 
331 // dofinal correct case
332 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest016, TestSize.Level0)
333 {
334     HcfResult res = HCF_SUCCESS;
335     uint8_t plan[] = "this is sm2 cipher test!\0";
336     HcfAsyKeyGenerator *generator = nullptr;
337     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
338     EXPECT_EQ(res, HCF_SUCCESS);
339     HcfKeyPair *keyPair = nullptr;
340     res = generator->generateKeyPair(generator, nullptr, &keyPair);
341     EXPECT_EQ(res, HCF_SUCCESS);
342     EXPECT_NE(keyPair, nullptr);
343     EXPECT_NE(keyPair->priKey, nullptr);
344     EXPECT_NE(keyPair->pubKey, nullptr);
345 
346     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
347     HcfBlob encoutput = {.data = nullptr, .len = 0};
348     HcfCipher *cipher = nullptr;
349     res = HcfCipherCreate("SM2|SM3", &cipher);
350     EXPECT_EQ(res, HCF_SUCCESS);
351 
352     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
353     EXPECT_EQ(res, HCF_SUCCESS);
354     res = cipher->doFinal(cipher, &input, &encoutput);
355     EXPECT_EQ(res, HCF_SUCCESS);
356     HcfObjDestroy(cipher);
357 
358     HcfBlob decoutput = {.data = nullptr, .len = 0};
359     cipher = nullptr;
360     res = HcfCipherCreate("SM2|SM3", &cipher);
361     EXPECT_EQ(res, HCF_SUCCESS);
362     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
363     EXPECT_EQ(res, HCF_SUCCESS);
364     res = cipher->doFinal(cipher, &encoutput, &decoutput);
365     EXPECT_EQ(res, HCF_SUCCESS);
366     HcfObjDestroy(cipher);
367     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
368 
369     HcfFree(encoutput.data);
370     HcfFree(decoutput.data);
371 
372     HcfObjDestroy(keyPair);
373     HcfObjDestroy(generator);
374 }
375 
376 // Correct case: test genEncoded and convert key
377 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest017, TestSize.Level0)
378 {
379     uint8_t plan[] = "this is sm2 cipher test!\0";
380     HcfAsyKeyGenerator *generator = nullptr;
381     HcfResult res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
382     EXPECT_EQ(res, HCF_SUCCESS);
383     EXPECT_NE(generator, nullptr);
384 
385     HcfKeyPair *keyPair = nullptr;
386     res = generator->generateKeyPair(generator, nullptr, &keyPair);
387     EXPECT_EQ(res, HCF_SUCCESS);
388     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
389     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
390     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
391     EXPECT_EQ(res, HCF_SUCCESS);
392     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
393     EXPECT_EQ(res, HCF_SUCCESS);
394 
395     HcfKeyPair *dupKeyPair = nullptr;
396     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
397     EXPECT_EQ(res, HCF_SUCCESS);
398 
399     HcfObjDestroy(generator);
400     HcfObjDestroy(keyPair);
401 
402     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
403     HcfBlob encoutput = {.data = nullptr, .len = 0};
404     HcfCipher *cipher = nullptr;
405     res = HcfCipherCreate("SM2|SM3", &cipher);
406     EXPECT_EQ(res, HCF_SUCCESS);
407 
408     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)dupKeyPair->pubKey, nullptr);
409     EXPECT_EQ(res, HCF_SUCCESS);
410     res = cipher->doFinal(cipher, &input, &encoutput);
411     EXPECT_EQ(res, HCF_SUCCESS);
412     HcfObjDestroy(cipher);
413 
414     HcfBlob decoutput = {.data = nullptr, .len = 0};
415     cipher = nullptr;
416     res = HcfCipherCreate("SM2|SM3", &cipher);
417     EXPECT_EQ(res, HCF_SUCCESS);
418     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)dupKeyPair->priKey, nullptr);
419     EXPECT_EQ(res, HCF_SUCCESS);
420     res = cipher->doFinal(cipher, &encoutput, &decoutput);
421     EXPECT_EQ(res, HCF_SUCCESS);
422     HcfObjDestroy(cipher);
423     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
424 
425     HcfFree(encoutput.data);
426     HcfFree(decoutput.data);
427     HcfFree(pubKeyBlob.data);
428     HcfFree(priKeyBlob.data);
429     HcfObjDestroy(dupKeyPair);
430 }
431 
432 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest018, TestSize.Level0)
433 {
434     HcfResult res = HCF_SUCCESS;
435     HcfAsyKeyGenerator *generator = nullptr;
436     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
437     EXPECT_EQ(res, HCF_SUCCESS);
438 
439     HcfKeyPair *keyPair = nullptr;
440     res = generator->generateKeyPair(generator, nullptr, &keyPair);
441     HcfCipher *cipher = nullptr;
442     res = HcfCipherCreate("SM2|SM3", &cipher);
443     EXPECT_EQ(res, HCF_SUCCESS);
444 
445     res = cipher->init((HcfCipher *)generator, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
446     EXPECT_NE(res, HCF_SUCCESS);
447 
448     HcfObjDestroy(generator);
449     HcfObjDestroy(cipher);
450     HcfObjDestroy(keyPair);
451 }
452 
453 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest019, TestSize.Level0)
454 {
455     HcfResult res = HCF_SUCCESS;
456     HcfAsyKeyGenerator *generator = nullptr;
457     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
458     HcfKeyPair *keyPair = nullptr;
459     res = generator->generateKeyPair(generator, nullptr, &keyPair);
460     EXPECT_EQ(res, HCF_SUCCESS);
461     EXPECT_NE(keyPair, nullptr);
462     EXPECT_NE(keyPair->priKey, nullptr);
463     EXPECT_NE(keyPair->pubKey, nullptr);
464 
465     HcfCipher *cipher = nullptr;
466     res = HcfCipherCreate("SM2|SM3", &cipher);
467     EXPECT_EQ(res, HCF_SUCCESS);
468 
469     uint8_t plan[] = "12312123123";
470     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
471 
472     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
473     EXPECT_EQ(res, HCF_SUCCESS);
474 
475     res = cipher->doFinal(cipher, &input, nullptr);
476     EXPECT_NE(res, HCF_SUCCESS);
477 
478     HcfObjDestroy(keyPair);
479     HcfObjDestroy(generator);
480     HcfObjDestroy(cipher);
481 }
482 
483 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest020, TestSize.Level0)
484 {
485     HcfResult res = HCF_SUCCESS;
486     HcfAsyKeyGenerator *generator = nullptr;
487     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
488     HcfKeyPair *keyPair = nullptr;
489     res = generator->generateKeyPair(generator, nullptr, &keyPair);
490     EXPECT_EQ(res, HCF_SUCCESS);
491     EXPECT_NE(keyPair, nullptr);
492     EXPECT_NE(keyPair->priKey, nullptr);
493     EXPECT_NE(keyPair->pubKey, nullptr);
494 
495     HcfCipher *cipher = nullptr;
496     res = HcfCipherCreate("SM2|SM3", &cipher);
497     EXPECT_EQ(res, HCF_SUCCESS);
498 
499     uint8_t plan[] = "12312123123";
500     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
501 
502     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
503     EXPECT_EQ(res, HCF_SUCCESS);
504 
505     HcfBlob blob;
506     res = cipher->doFinal((HcfCipher *)generator, &input, &blob);
507     EXPECT_NE(res, HCF_SUCCESS);
508 
509     HcfObjDestroy(keyPair);
510     HcfObjDestroy(generator);
511     HcfObjDestroy(cipher);
512 }
513 
514 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest021, TestSize.Level0)
515 {
516     HcfResult res = HCF_SUCCESS;
517     HcfCipher *cipher = nullptr;
518     res = HcfCipherCreate("SM5|PK1", &cipher);
519     EXPECT_NE(res, HCF_SUCCESS);
520 }
521 
522 // incorrect : init Cipher twice
523 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest022, TestSize.Level0)
524 {
525     HcfResult res = HCF_SUCCESS;
526     HcfAsyKeyGenerator *generator = nullptr;
527     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
528     EXPECT_EQ(res, HCF_SUCCESS);
529     HcfKeyPair *keyPair = nullptr;
530     res = generator->generateKeyPair(generator, nullptr, &keyPair);
531     EXPECT_EQ(res, HCF_SUCCESS);
532 
533     HcfCipher *cipher = nullptr;
534     res = HcfCipherCreate("SM2|SM3", &cipher);
535     EXPECT_EQ(res, HCF_SUCCESS);
536     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
537     EXPECT_EQ(res, HCF_SUCCESS);
538     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
539     EXPECT_NE(res, HCF_SUCCESS);
540 
541     HcfObjDestroy(keyPair);
542     HcfObjDestroy(generator);
543     HcfObjDestroy(cipher);
544 }
545 
546 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest023, TestSize.Level0)
547 {
548     HcfResult res = HCF_SUCCESS;
549     HcfAsyKeyGenerator *generator = nullptr;
550     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
551     EXPECT_EQ(res, HCF_SUCCESS);
552     HcfKeyPair *keyPair = nullptr;
553     res = generator->generateKeyPair(generator, nullptr, &keyPair);
554     EXPECT_EQ(res, HCF_SUCCESS);
555 
556     HcfCipher *cipher = nullptr;
557     res = HcfCipherCreate("SM2|SM3", &cipher);
558     EXPECT_EQ(res, HCF_SUCCESS);
559     res = cipher->init(nullptr, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
560     EXPECT_NE(res, HCF_SUCCESS);
561 
562     HcfObjDestroy(keyPair);
563     HcfObjDestroy(generator);
564     HcfObjDestroy(cipher);
565 }
566 
567 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest024, TestSize.Level0)
568 {
569     HcfResult res = HCF_SUCCESS;
570     HcfAsyKeyGenerator *generator = nullptr;
571     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
572     EXPECT_EQ(res, HCF_SUCCESS);
573     HcfKeyPair *keyPair = nullptr;
574     res = generator->generateKeyPair(generator, nullptr, &keyPair);
575     EXPECT_EQ(res, HCF_SUCCESS);
576 
577     HcfCipher *cipher = nullptr;
578     res = HcfCipherCreate("SM2|SM3", &cipher);
579     EXPECT_EQ(res, HCF_SUCCESS);
580     res = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr);
581     EXPECT_NE(res, HCF_SUCCESS);
582 
583     HcfObjDestroy(keyPair);
584     HcfObjDestroy(generator);
585     HcfObjDestroy(cipher);
586 }
587 
588 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest025, TestSize.Level0)
589 {
590     HcfResult res = HCF_SUCCESS;
591     HcfAsyKeyGenerator *generator = nullptr;
592     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
593     EXPECT_EQ(res, HCF_SUCCESS);
594     HcfKeyPair *keyPair = nullptr;
595     res = generator->generateKeyPair(generator, nullptr, &keyPair);
596     EXPECT_EQ(res, HCF_SUCCESS);
597     EXPECT_NE(keyPair, nullptr);
598     EXPECT_NE(keyPair->priKey, nullptr);
599     EXPECT_NE(keyPair->pubKey, nullptr);
600 
601     HcfBlob encoutput = {.data = nullptr, .len = 0};
602     HcfCipher *cipher = nullptr;
603     res = HcfCipherCreate("SM2|SM3", &cipher);
604     EXPECT_EQ(res, HCF_SUCCESS);
605 
606     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
607     EXPECT_EQ(res, HCF_SUCCESS);
608     res = cipher->doFinal(cipher, nullptr, &encoutput);
609     EXPECT_NE(res, HCF_SUCCESS);
610     HcfObjDestroy(cipher);
611 
612     HcfFree(encoutput.data);
613 
614     HcfObjDestroy(keyPair);
615     HcfObjDestroy(generator);
616 }
617 
618 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest026, TestSize.Level0)
619 {
620     HcfResult res = HCF_SUCCESS;
621     uint8_t plan[] = "this is sm2 cipher test!\0";
622     HcfAsyKeyGenerator *generator = nullptr;
623     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
624     EXPECT_EQ(res, HCF_SUCCESS);
625     HcfKeyPair *keyPair = nullptr;
626     res = generator->generateKeyPair(generator, nullptr, &keyPair);
627     EXPECT_EQ(res, HCF_SUCCESS);
628     EXPECT_NE(keyPair, nullptr);
629     EXPECT_NE(keyPair->priKey, nullptr);
630     EXPECT_NE(keyPair->pubKey, nullptr);
631 
632     HcfBlob encoutput = {.data = nullptr, .len = 0};
633     HcfCipher *cipher = nullptr;
634     res = HcfCipherCreate("SM2|SM3", &cipher);
635     EXPECT_EQ(res, HCF_SUCCESS);
636     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
637     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
638     EXPECT_EQ(res, HCF_SUCCESS);
639     res = cipher->doFinal(nullptr, &input, &encoutput);
640     EXPECT_NE(res, HCF_SUCCESS);
641     HcfObjDestroy(cipher);
642 
643     HcfFree(encoutput.data);
644 
645     HcfObjDestroy(keyPair);
646     HcfObjDestroy(generator);
647 }
648 
649 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest027, TestSize.Level0)
650 {
651     HcfResult res = HCF_SUCCESS;
652     HcfCipher *cipher = nullptr;
653     res = HcfCipherCreate("SM2|SM3", &cipher);
654     EXPECT_EQ(res, HCF_SUCCESS);
655 
656     cipher->base.destroy(nullptr);
657 
658     HcfObjDestroy(cipher);
659 }
660 
661 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest028, TestSize.Level0)
662 {
663     HcfResult res = HCF_SUCCESS;
664     HcfCipher *cipher = nullptr;
665     res = HcfCipherCreate("SM2|SM3", &cipher);
666     EXPECT_EQ(res, HCF_SUCCESS);
667 
668     cipher->base.destroy(&obj);
669 
670     HcfObjDestroy(cipher);
671 }
672 
673 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest029, TestSize.Level0)
674 {
675     HcfResult res = HCF_SUCCESS;
676     HcfCipherGeneratorSpi *cipher = nullptr;
677     res = HcfCipherSm2CipherSpiCreate(nullptr, &cipher);
678 
679     ASSERT_EQ(res, HCF_INVALID_PARAMS);
680     ASSERT_EQ(cipher, nullptr);
681 
682     HcfObjDestroy(cipher);
683 }
684 
685 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest030, TestSize.Level0)
686 {
687     HcfResult res = HCF_SUCCESS;
688     HcfCipherGeneratorSpi *cipher = nullptr;
689     CipherAttr params = {
690         .algo = HCF_ALG_SM2,
691         .md = HCF_OPENSSL_DIGEST_SM3,
692     };
693     res = HcfCipherSm2CipherSpiCreate(&params, nullptr);
694     ASSERT_EQ(res, HCF_INVALID_PARAMS);
695     HcfObjDestroy(cipher);
696 }
697 
698 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest031, TestSize.Level0)
699 {
700     HcfResult res = HCF_SUCCESS;
701     HcfCipherGeneratorSpi *cipher = nullptr;
702     CipherAttr params = {
703         .algo = HCF_ALG_SM2,
704         .md = HCF_OPENSSL_DIGEST_SM3,
705     };
706     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
707     EXPECT_EQ(res, HCF_SUCCESS);
708     res = cipher->init(cipher, (enum HcfCryptoMode)123, (HcfKey *)sm2256KeyPair_->pubKey, nullptr);
709     ASSERT_EQ(res, HCF_INVALID_PARAMS);
710 
711     HcfObjDestroy(cipher);
712 }
713 
714 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest032, TestSize.Level0)
715 {
716     HcfResult res = HCF_SUCCESS;
717     HcfCipherGeneratorSpi *cipher = nullptr;
718     CipherAttr params = {
719         .algo = HCF_ALG_SM2,
720         .md = HCF_OPENSSL_DIGEST_SM3,
721     };
722     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
723     EXPECT_EQ(res, HCF_SUCCESS);
724     res = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr);
725     ASSERT_EQ(res, HCF_INVALID_PARAMS);
726 
727     HcfObjDestroy(cipher);
728 }
729 
730 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest033, TestSize.Level0)
731 {
732     HcfResult res = HCF_SUCCESS;
733     HcfCipherGeneratorSpi *cipher = nullptr;
734     CipherAttr params = {
735         .algo = HCF_ALG_SM2,
736         .md = HCF_OPENSSL_DIGEST_SM3,
737     };
738     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
739     EXPECT_EQ(res, HCF_SUCCESS);
740     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)sm2256KeyPair_->priKey, nullptr);
741     ASSERT_EQ(res, HCF_INVALID_PARAMS);
742 
743     HcfObjDestroy(cipher);
744 }
745 
746 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest034, TestSize.Level0)
747 {
748     HcfResult res = HCF_SUCCESS;
749     HcfCipherGeneratorSpi *cipher = nullptr;
750     CipherAttr params = {
751         .algo = HCF_ALG_SM2,
752         .md = HCF_OPENSSL_DIGEST_SM3,
753     };
754     const char *message = "hello world";
755     HcfBlob input = {
756         .data = (uint8_t *)message,
757         .len = 12
758     };
759     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
760     EXPECT_EQ(res, HCF_SUCCESS);
761     res = cipher->doFinal(cipher, &input, nullptr);
762     ASSERT_EQ(res, HCF_INVALID_PARAMS);
763 
764     HcfObjDestroy(cipher);
765 }
766 
767 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest035, TestSize.Level0)
768 {
769     HcfResult res = HCF_SUCCESS;
770     HcfCipherGeneratorSpi *cipher = nullptr;
771     CipherAttr params = {
772         .algo = HCF_ALG_SM2,
773         .md = HCF_OPENSSL_DIGEST_SM3,
774     };
775     HcfBlob out = { .data = nullptr, .len = 0 };
776     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
777     EXPECT_EQ(res, HCF_SUCCESS);
778     res = cipher->doFinal(cipher, nullptr, &out);
779     ASSERT_EQ(res, HCF_INVALID_PARAMS);
780 
781     HcfObjDestroy(cipher);
782 }
783 
784 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest036, TestSize.Level0)
785 {
786     HcfResult res = HCF_SUCCESS;
787     HcfCipherGeneratorSpi *cipher = nullptr;
788     CipherAttr params = {
789         .algo = HCF_ALG_SM2,
790         .md = HCF_OPENSSL_DIGEST_SM3,
791     };
792     const char *message = "hello world";
793     HcfBlob input = {
794         .data = (uint8_t *)message,
795         .len = 12
796     };
797     HcfBlob out = { .data = nullptr, .len = 0 };
798     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
799     EXPECT_EQ(res, HCF_SUCCESS);
800     res = cipher->doFinal(nullptr, &input, &out);
801     ASSERT_EQ(res, HCF_INVALID_PARAMS);
802 
803     HcfObjDestroy(cipher);
804 }
805 
806 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest037, TestSize.Level0)
807 {
808     HcfResult res = HCF_SUCCESS;
809     HcfCipherGeneratorSpi *cipher = nullptr;
810     CipherAttr params = {
811         .algo = HCF_ALG_SM2,
812         .md = HCF_OPENSSL_DIGEST_SM3,
813     };
814     HcfBlob input = {
815         .data = nullptr,
816         .len = 12
817     };
818     HcfBlob out = { .data = nullptr, .len = 0 };
819     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
820     EXPECT_EQ(res, HCF_SUCCESS);
821     res = cipher->doFinal(cipher, &input, &out);
822     ASSERT_EQ(res, HCF_INVALID_PARAMS);
823 
824     HcfObjDestroy(cipher);
825 }
826 
827 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest038, TestSize.Level0)
828 {
829     HcfResult res = HCF_SUCCESS;
830     HcfCipherGeneratorSpi *cipher = nullptr;
831     CipherAttr params = {
832         .algo = HCF_ALG_SM2,
833         .md = HCF_OPENSSL_DIGEST_SM3,
834     };
835     const char *message = "hello world";
836     HcfBlob input = {
837         .data = (uint8_t *)message,
838         .len = 0
839     };
840     HcfBlob out = { .data = nullptr, .len = 0 };
841     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
842     EXPECT_EQ(res, HCF_SUCCESS);
843     res = cipher->doFinal(cipher, &input, &out);
844     ASSERT_EQ(res, HCF_INVALID_PARAMS);
845 
846     HcfObjDestroy(cipher);
847 }
848 
849 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest039, TestSize.Level0)
850 {
851     HcfResult res = HCF_SUCCESS;
852     HcfCipher *cipher = nullptr;
853     res = HcfCipherCreate("SM2|NoHash", &cipher);
854     EXPECT_NE(res, HCF_SUCCESS);
855     EXPECT_EQ(cipher, nullptr);
856 }
857 
858 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest040, TestSize.Level0)
859 {
860     HcfResult res = HCF_SUCCESS;
861     HcfCipherGeneratorSpi *cipher = nullptr;
862     CipherAttr params = {
863         .algo = HCF_ALG_SM2,
864         .md = HCF_OPENSSL_DIGEST_SM3,
865     };
866     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
867     EXPECT_EQ(res, HCF_SUCCESS);
868     cipher->base.destroy(nullptr);
869     HcfObjDestroy(cipher);
870 }
871 
872 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest042, TestSize.Level0)
873 {
874     HcfResult res = HCF_SUCCESS;
875     HcfAsyKeyGenerator *generator = nullptr;
876     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
877     EXPECT_EQ(res, HCF_SUCCESS);
878     HcfKeyPair *keyPair = nullptr;
879     res = generator->generateKeyPair(generator, nullptr, &keyPair);
880     EXPECT_EQ(res, HCF_SUCCESS);
881     HcfCipher *cipher = nullptr;
882     res = HcfCipherCreate("SM2|SM3", &cipher);
883     EXPECT_EQ(res, HCF_SUCCESS);
884     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
885     EXPECT_NE(res, HCF_SUCCESS);
886 
887     HcfObjDestroy(keyPair);
888     HcfObjDestroy(generator);
889     HcfObjDestroy(cipher);
890 }
891 
892 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest048, TestSize.Level0)
893 {
894     HcfResult res = HCF_SUCCESS;
895     HcfAsyKeyGenerator *generator = nullptr;
896     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
897     EXPECT_EQ(res, HCF_SUCCESS);
898     HcfKeyPair *keyPair = nullptr;
899     res = generator->generateKeyPair(generator, nullptr, &keyPair);
900     EXPECT_EQ(res, HCF_SUCCESS);
901     HcfCipherGeneratorSpi *cipher = nullptr;
902     CipherAttr params = {
903         .algo = HCF_ALG_SM2,
904         .md = HCF_OPENSSL_DIGEST_SM3,
905     };
906     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
907     EXPECT_EQ(res, HCF_SUCCESS);
908     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
909     EXPECT_EQ(res, HCF_SUCCESS);
910     char *returnStr = nullptr;
911     res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr);
912     EXPECT_EQ(res, HCF_SUCCESS);
913 
914     HcfFree(returnStr);
915     HcfObjDestroy(keyPair);
916     HcfObjDestroy(generator);
917     HcfObjDestroy(cipher);
918 }
919 
920 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest049, TestSize.Level0)
921 {
922     HcfResult res = HCF_SUCCESS;
923     HcfAsyKeyGenerator *generator = nullptr;
924     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
925     EXPECT_EQ(res, HCF_SUCCESS);
926     HcfKeyPair *keyPair = nullptr;
927     res = generator->generateKeyPair(generator, nullptr, &keyPair);
928     EXPECT_EQ(res, HCF_SUCCESS);
929     HcfCipherGeneratorSpi *cipher = nullptr;
930     CipherAttr params = {
931         .algo = HCF_ALG_SM2,
932         .md = HCF_OPENSSL_DIGEST_SM3,
933     };
934     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
935     EXPECT_EQ(res, HCF_SUCCESS);
936     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
937     EXPECT_EQ(res, HCF_SUCCESS);
938     char *returnStr = nullptr;
939     res = cipher->getCipherSpecString(cipher, OAEP_MGF1_PSRC_UINT8ARR, &returnStr);
940     EXPECT_EQ(res, HCF_INVALID_PARAMS);
941 
942     HcfFree(returnStr);
943     HcfObjDestroy(keyPair);
944     HcfObjDestroy(generator);
945     HcfObjDestroy(cipher);
946 }
947 
948 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest050, TestSize.Level0)
949 {
950     HcfResult res = HCF_SUCCESS;
951     HcfAsyKeyGenerator *generator = nullptr;
952     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
953     EXPECT_EQ(res, HCF_SUCCESS);
954     HcfKeyPair *keyPair = nullptr;
955     res = generator->generateKeyPair(generator, nullptr, &keyPair);
956     EXPECT_EQ(res, HCF_SUCCESS);
957     HcfCipherGeneratorSpi *cipher = nullptr;
958     CipherAttr params = {
959         .algo = HCF_ALG_SM2,
960         .md = HCF_OPENSSL_DIGEST_SM3,
961     };
962     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
963     EXPECT_EQ(res, HCF_SUCCESS);
964     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
965     EXPECT_EQ(res, HCF_SUCCESS);
966     res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, nullptr);
967     EXPECT_EQ(res, HCF_INVALID_PARAMS);
968 
969     HcfObjDestroy(keyPair);
970     HcfObjDestroy(generator);
971     HcfObjDestroy(cipher);
972 }
973 
974 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest051, TestSize.Level0)
975 {
976     HcfResult res = HCF_SUCCESS;
977     HcfAsyKeyGenerator *generator = nullptr;
978     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
979     EXPECT_EQ(res, HCF_SUCCESS);
980     HcfKeyPair *keyPair = nullptr;
981     res = generator->generateKeyPair(generator, nullptr, &keyPair);
982     EXPECT_EQ(res, HCF_SUCCESS);
983     HcfCipherGeneratorSpi *cipher = nullptr;
984     CipherAttr params = {
985         .algo = HCF_ALG_SM2,
986         .md = HCF_OPENSSL_DIGEST_SM3,
987     };
988     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
989     EXPECT_EQ(res, HCF_SUCCESS);
990     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
991     EXPECT_EQ(res, HCF_SUCCESS);
992     char *returnStr = nullptr;
993     res = cipher->getCipherSpecString(nullptr, SM2_MD_NAME_STR, &returnStr);
994     EXPECT_EQ(res, HCF_INVALID_PARAMS);
995 
996     HcfFree(returnStr);
997     HcfObjDestroy(keyPair);
998     HcfObjDestroy(generator);
999     HcfObjDestroy(cipher);
1000 }
1001 
1002 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest052, TestSize.Level0)
1003 {
1004     HcfResult res = HCF_SUCCESS;
1005     HcfAsyKeyGenerator *generator = nullptr;
1006     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1007     EXPECT_EQ(res, HCF_SUCCESS);
1008     HcfKeyPair *keyPair = nullptr;
1009     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1010     EXPECT_EQ(res, HCF_SUCCESS);
1011     HcfCipherGeneratorSpi *cipher = nullptr;
1012     CipherAttr params = {
1013         .algo = HCF_ALG_SM2,
1014         .md = HCF_OPENSSL_DIGEST_SM3,
1015     };
1016     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1017     EXPECT_EQ(res, HCF_SUCCESS);
1018     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1019     EXPECT_EQ(res, HCF_SUCCESS);
1020     char *returnStr = nullptr;
1021     res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr);
1022     EXPECT_EQ(res, HCF_SUCCESS);
1023 
1024     HcfFree(returnStr);
1025     HcfObjDestroy(keyPair);
1026     HcfObjDestroy(generator);
1027     HcfObjDestroy(cipher);
1028 }
1029 
1030     HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest053, TestSize.Level0)
1031 {
1032     HcfResult res = HCF_SUCCESS;
1033     HcfAsyKeyGenerator *generator = nullptr;
1034     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1035     EXPECT_EQ(res, HCF_SUCCESS);
1036     HcfKeyPair *keyPair = nullptr;
1037     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1038     EXPECT_EQ(res, HCF_SUCCESS);
1039     HcfCipherGeneratorSpi *cipher = nullptr;
1040     CipherAttr params = {
1041         .algo = HCF_ALG_SM2,
1042         .md = HCF_OPENSSL_DIGEST_SM3,
1043     };
1044     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1045     EXPECT_EQ(res, HCF_SUCCESS);
1046     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1047     EXPECT_EQ(res, HCF_SUCCESS);
1048     char *returnStr = nullptr;
1049     res = cipher->getCipherSpecString(cipher, OAEP_MGF1_PSRC_UINT8ARR, &returnStr);
1050     EXPECT_EQ(res, HCF_INVALID_PARAMS);
1051 
1052     HcfFree(returnStr);
1053     HcfObjDestroy(keyPair);
1054     HcfObjDestroy(generator);
1055     HcfObjDestroy(cipher);
1056 }
1057 
1058 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest054, TestSize.Level0)
1059 {
1060     HcfResult res = HCF_SUCCESS;
1061     HcfAsyKeyGenerator *generator = nullptr;
1062     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1063     EXPECT_EQ(res, HCF_SUCCESS);
1064     HcfKeyPair *keyPair = nullptr;
1065     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1066     EXPECT_EQ(res, HCF_SUCCESS);
1067     HcfCipherGeneratorSpi *cipher = nullptr;
1068     CipherAttr params = {
1069         .algo = HCF_ALG_SM2,
1070         .md = HCF_OPENSSL_DIGEST_SM3,
1071     };
1072     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1073     EXPECT_EQ(res, HCF_SUCCESS);
1074     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1075     EXPECT_EQ(res, HCF_SUCCESS);
1076     res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, nullptr);
1077     EXPECT_EQ(res, HCF_INVALID_PARAMS);
1078 
1079     HcfObjDestroy(keyPair);
1080     HcfObjDestroy(generator);
1081     HcfObjDestroy(cipher);
1082 }
1083 
1084 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest055, TestSize.Level0)
1085 {
1086     HcfResult res = HCF_SUCCESS;
1087     HcfAsyKeyGenerator *generator = nullptr;
1088     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1089     EXPECT_EQ(res, HCF_SUCCESS);
1090     HcfKeyPair *keyPair = nullptr;
1091     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1092     EXPECT_EQ(res, HCF_SUCCESS);
1093     HcfCipherGeneratorSpi *cipher = nullptr;
1094     CipherAttr params = {
1095         .algo = HCF_ALG_SM2,
1096         .md = HCF_OPENSSL_DIGEST_SM3,
1097     };
1098     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1099     EXPECT_EQ(res, HCF_SUCCESS);
1100     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1101     EXPECT_EQ(res, HCF_SUCCESS);
1102     char *returnStr = nullptr;
1103     res = cipher->getCipherSpecString(nullptr, SM2_MD_NAME_STR, &returnStr);
1104     EXPECT_EQ(res, HCF_INVALID_PARAMS);
1105 
1106     HcfFree(returnStr);
1107     HcfObjDestroy(keyPair);
1108     HcfObjDestroy(generator);
1109     HcfObjDestroy(cipher);
1110 }
1111 
1112 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest056, TestSize.Level0)
1113 {
1114     HcfResult res = HCF_SUCCESS;
1115     HcfAsyKeyGenerator *generator = nullptr;
1116     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1117     EXPECT_EQ(res, HCF_SUCCESS);
1118     HcfKeyPair *keyPair = nullptr;
1119     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1120     EXPECT_EQ(res, HCF_SUCCESS);
1121     HcfCipherGeneratorSpi *cipher = nullptr;
1122     CipherAttr params = {
1123         .algo = HCF_ALG_SM2,
1124         .md = HCF_OPENSSL_DIGEST_SM3,
1125     };
1126     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1127     EXPECT_EQ(res, HCF_SUCCESS);
1128     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1129     EXPECT_EQ(res, HCF_SUCCESS);
1130     HcfBlob returnUint8Array = {.data = nullptr, .len = 0};
1131     res = cipher->getCipherSpecUint8Array(cipher, SM2_MD_NAME_STR, &returnUint8Array);
1132     EXPECT_EQ(res, HCF_NOT_SUPPORT);
1133 
1134     HcfFree(returnUint8Array.data);
1135     HcfObjDestroy(keyPair);
1136     HcfObjDestroy(generator);
1137     HcfObjDestroy(cipher);
1138 }
1139 
1140 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest057, TestSize.Level0)
1141 {
1142     HcfResult res = HCF_SUCCESS;
1143     HcfAsyKeyGenerator *generator = nullptr;
1144     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1145     EXPECT_EQ(res, HCF_SUCCESS);
1146     HcfKeyPair *keyPair = nullptr;
1147     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1148     EXPECT_EQ(res, HCF_SUCCESS);
1149     HcfCipherGeneratorSpi *cipher = nullptr;
1150     CipherAttr params = {
1151         .algo = HCF_ALG_SM2,
1152         .md = HCF_OPENSSL_DIGEST_SM3,
1153     };
1154     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1155     EXPECT_EQ(res, HCF_SUCCESS);
1156     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1157     EXPECT_EQ(res, HCF_SUCCESS);
1158     HcfBlob pSource = {.data = nullptr, .len = 0};
1159     res = cipher->setCipherSpecUint8Array(cipher, SM2_MD_NAME_STR, pSource);
1160     EXPECT_EQ(res, HCF_NOT_SUPPORT);
1161 
1162     HcfFree(pSource.data);
1163     HcfObjDestroy(keyPair);
1164     HcfObjDestroy(generator);
1165     HcfObjDestroy(cipher);
1166 }
1167 
1168 HWTEST_F(CryptoSm2CipherTest, CryptoSm2CipherTest058, TestSize.Level0)
1169 {
1170     HcfResult res = HCF_SUCCESS;
1171     uint8_t plan[] = "this is sm2 cipher test!\0";
1172     HcfAsyKeyGenerator *generator = nullptr;
1173     res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1174     EXPECT_EQ(res, HCF_SUCCESS);
1175     HcfKeyPair *keyPair = nullptr;
1176     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1177     EXPECT_EQ(res, HCF_SUCCESS);
1178     EXPECT_NE(keyPair, nullptr);
1179     EXPECT_NE(keyPair->priKey, nullptr);
1180     EXPECT_NE(keyPair->pubKey, nullptr);
1181 
1182     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan) + 1};
1183     HcfBlob encoutput = {.data = nullptr, .len = 0};
1184     HcfCipherGeneratorSpi *cipher = nullptr;
1185     CipherAttr params = {
1186         .algo = HCF_ALG_SM2,
1187         .md = HCF_OPENSSL_DIGEST_SM3,
1188     };
1189     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1190     EXPECT_EQ(res, HCF_SUCCESS);
1191 
1192     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1193     EXPECT_EQ(res, HCF_SUCCESS);
1194     char *returnStr = nullptr;
1195     res = cipher->getCipherSpecString(cipher, SM2_MD_NAME_STR, &returnStr);
1196     EXPECT_EQ(res, HCF_SUCCESS);
1197     res = cipher->doFinal(cipher, &input, &encoutput);
1198     EXPECT_EQ(res, HCF_SUCCESS);
1199     HcfFree(returnStr);
1200     HcfObjDestroy(cipher);
1201 
1202     HcfBlob decoutput = {.data = nullptr, .len = 0};
1203     cipher = nullptr;
1204     res = HcfCipherSm2CipherSpiCreate(&params, &cipher);
1205     EXPECT_EQ(res, HCF_SUCCESS);
1206     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1207     EXPECT_EQ(res, HCF_SUCCESS);
1208     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1209     EXPECT_EQ(res, HCF_SUCCESS);
1210     HcfObjDestroy(cipher);
1211     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1212 
1213     HcfFree(encoutput.data);
1214     HcfFree(decoutput.data);
1215 
1216     HcfObjDestroy(keyPair);
1217     HcfObjDestroy(generator);
1218 }
1219 }
1220