• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "crypto_common.h"
18 #include "crypto_asym_key.h"
19 #include "log.h"
20 #include "memory.h"
21 #include "memory_mock.h"
22 
23 using namespace std;
24 using namespace testing::ext;
25 
26 static string g_testPubkeyX509Str512 = "-----BEGIN PUBLIC KEY-----\n"
27 "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKG0KN3tjZM8dCNfCg9bcmZM3Bhv/mRr\n"
28 "Mxuvua2Ru8Kr1NL+/wyeEMnIARFr+Alf1Tyfjy0PWwFnf8jHWRsz0vkCAwEAAQ==\n"
29 "-----END PUBLIC KEY-----\n";
30 
31 static string g_testPubkeyPkcs1Str512 = "-----BEGIN RSA PUBLIC KEY-----\n"
32 "MEgCQQChtCjd7Y2TPHQjXwoPW3JmTNwYb/5kazMbr7mtkbvCq9TS/v8MnhDJyAER\n"
33 "a/gJX9U8n48tD1sBZ3/Ix1kbM9L5AgMBAAE=\n"
34 "-----END RSA PUBLIC KEY-----\n";
35 
36 namespace {
37 class NativeAsymKeyTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase()45 void NativeAsymKeyTest::SetUpTestCase() {}
TearDownTestCase()46 void NativeAsymKeyTest::TearDownTestCase() {}
47 
SetUp()48 void NativeAsymKeyTest::SetUp() // add init here, this will be called before test.
49 {
50 }
51 
TearDown()52 void NativeAsymKeyTest::TearDown() // add destroy here, this will be called when test case done.
53 {
54 }
55 
GenerateKeyPair(const char * algName)56 static OH_CryptoKeyPair *GenerateKeyPair(const char *algName)
57 {
58     OH_CryptoAsymKeyGenerator *generator = nullptr;
59     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create(algName, &generator);
60     if (ret != CRYPTO_SUCCESS) {
61         return nullptr;
62     }
63 
64     OH_CryptoKeyPair *keyCtx = nullptr;
65     ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx);
66     if (ret != CRYPTO_SUCCESS) {
67         OH_CryptoAsymKeyGenerator_Destroy(generator);
68         return nullptr;
69     }
70 
71     OH_CryptoAsymKeyGenerator_Destroy(generator);
72     return keyCtx;
73 }
74 
GenerateKeyPairWithSpec(OH_CryptoAsymKeySpec * keySpec,OH_CryptoKeyPair ** keyPair)75 static OH_Crypto_ErrCode GenerateKeyPairWithSpec(OH_CryptoAsymKeySpec *keySpec, OH_CryptoKeyPair **keyPair)
76 {
77     OH_CryptoAsymKeyGeneratorWithSpec *generatorSpec = nullptr;
78     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGeneratorWithSpec_Create(keySpec, &generatorSpec);
79     if (ret != CRYPTO_SUCCESS) {
80         return ret;
81     }
82     ret = OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generatorSpec, keyPair);
83     OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generatorSpec);
84     return ret;
85 }
86 
GetDsaKeyParams(OH_CryptoKeyPair * keyCtx,Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData,Crypto_DataBlob * pData,Crypto_DataBlob * qData,Crypto_DataBlob * gData)87 static OH_Crypto_ErrCode GetDsaKeyParams(OH_CryptoKeyPair *keyCtx, Crypto_DataBlob *pubKeyData,
88                                          Crypto_DataBlob *privKeyData, Crypto_DataBlob *pData, Crypto_DataBlob *qData,
89                                          Crypto_DataBlob *gData)
90 {
91     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
92     if (pubKey == nullptr) {
93         return CRYPTO_OPERTION_ERROR;
94     }
95     OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_PK_DATABLOB, pubKeyData);
96     if (ret != CRYPTO_SUCCESS) {
97         return ret;
98     }
99 
100     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyCtx);
101     if (privKey == nullptr) {
102         return CRYPTO_OPERTION_ERROR;
103     }
104     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DSA_SK_DATABLOB, privKeyData);
105     if (ret != CRYPTO_SUCCESS) {
106         return ret;
107     }
108     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DSA_P_DATABLOB, pData);
109     if (ret != CRYPTO_SUCCESS) {
110         return ret;
111     }
112     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DSA_Q_DATABLOB, qData);
113     if (ret != CRYPTO_SUCCESS) {
114         return ret;
115     }
116     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DSA_G_DATABLOB, gData);
117     return ret;
118 }
119 
GetRsaKeyParams(OH_CryptoKeyPair * keyCtx,Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData,Crypto_DataBlob * nData)120 static OH_Crypto_ErrCode GetRsaKeyParams(OH_CryptoKeyPair *keyCtx, Crypto_DataBlob *pubKeyData,
121                                          Crypto_DataBlob *privKeyData, Crypto_DataBlob *nData)
122 {
123     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
124     if (pubKey == nullptr) {
125         return CRYPTO_OPERTION_ERROR;
126     }
127     OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, pubKeyData);
128     if (ret != CRYPTO_SUCCESS) {
129         return ret;
130     }
131 
132     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyCtx);
133     if (privKey == nullptr) {
134         return CRYPTO_OPERTION_ERROR;
135     }
136     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_RSA_D_DATABLOB, privKeyData);
137     if (ret != CRYPTO_SUCCESS) {
138         return ret;
139     }
140     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_RSA_N_DATABLOB, nData);
141     return ret;
142 }
143 
GetDhKeyParams(OH_CryptoKeyPair * keyCtx,Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData)144 static OH_Crypto_ErrCode GetDhKeyParams(OH_CryptoKeyPair *keyCtx, Crypto_DataBlob *pubKeyData,
145                                         Crypto_DataBlob *privKeyData)
146 {
147     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
148     if (pubKey == nullptr) {
149         return CRYPTO_OPERTION_ERROR;
150     }
151     OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_PK_DATABLOB, pubKeyData);
152     if (ret != CRYPTO_SUCCESS) {
153         return ret;
154     }
155 
156     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyCtx);
157     if (privKey == nullptr) {
158         return CRYPTO_OPERTION_ERROR;
159     }
160     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DH_SK_DATABLOB, privKeyData);
161     return ret;
162 }
163 
GetX25519KeyParams(OH_CryptoKeyPair * keyCtx,Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData)164 static OH_Crypto_ErrCode GetX25519KeyParams(OH_CryptoKeyPair *keyCtx, Crypto_DataBlob *pubKeyData,
165                                             Crypto_DataBlob *privKeyData)
166 {
167     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
168     if (pubKey == nullptr) {
169         return CRYPTO_OPERTION_ERROR;
170     }
171     OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_X25519_PK_DATABLOB, pubKeyData);
172     if (ret != CRYPTO_SUCCESS) {
173         return ret;
174     }
175 
176     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyCtx);
177     if (privKey == nullptr) {
178         return CRYPTO_OPERTION_ERROR;
179     }
180     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_X25519_SK_DATABLOB, privKeyData);
181     return ret;
182 }
183 
GetEccKeyParams(OH_CryptoKeyPair * keyCtx,Crypto_DataBlob * pubKeyXData,Crypto_DataBlob * pubKeyYData,Crypto_DataBlob * privKeyData)184 static OH_Crypto_ErrCode GetEccKeyParams(OH_CryptoKeyPair *keyCtx, Crypto_DataBlob *pubKeyXData,
185                                          Crypto_DataBlob *pubKeyYData, Crypto_DataBlob *privKeyData)
186 {
187     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
188     if (pubKey == nullptr) {
189         return CRYPTO_OPERTION_ERROR;
190     }
191     OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_X_DATABLOB, pubKeyXData);
192     if (ret != CRYPTO_SUCCESS) {
193         return ret;
194     }
195     ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_Y_DATABLOB, pubKeyYData);
196     if (ret != CRYPTO_SUCCESS) {
197         return ret;
198     }
199 
200     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyCtx);
201     if (privKey == nullptr) {
202         return CRYPTO_OPERTION_ERROR;
203     }
204     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_ECC_SK_DATABLOB, privKeyData);
205     return ret;
206 }
207 
FreeDsaKeyParams(Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData,Crypto_DataBlob * pData,Crypto_DataBlob * qData,Crypto_DataBlob * gData)208 static void FreeDsaKeyParams(Crypto_DataBlob *pubKeyData, Crypto_DataBlob *privKeyData, Crypto_DataBlob *pData,
209                              Crypto_DataBlob *qData, Crypto_DataBlob *gData)
210 {
211     OH_Crypto_FreeDataBlob(pubKeyData);
212     OH_Crypto_FreeDataBlob(privKeyData);
213     OH_Crypto_FreeDataBlob(pData);
214     OH_Crypto_FreeDataBlob(qData);
215     OH_Crypto_FreeDataBlob(gData);
216 }
217 
FreeRsaKeyParams(Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData,Crypto_DataBlob * nData)218 static void FreeRsaKeyParams(Crypto_DataBlob *pubKeyData, Crypto_DataBlob *privKeyData, Crypto_DataBlob *nData)
219 {
220     OH_Crypto_FreeDataBlob(pubKeyData);
221     OH_Crypto_FreeDataBlob(privKeyData);
222     OH_Crypto_FreeDataBlob(nData);
223 }
224 
FreeDhKeyParams(Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData)225 static void FreeDhKeyParams(Crypto_DataBlob *pubKeyData, Crypto_DataBlob *privKeyData)
226 {
227     OH_Crypto_FreeDataBlob(pubKeyData);
228     OH_Crypto_FreeDataBlob(privKeyData);
229 }
230 
FreeX25519KeyParams(Crypto_DataBlob * pubKeyData,Crypto_DataBlob * privKeyData)231 static void FreeX25519KeyParams(Crypto_DataBlob *pubKeyData, Crypto_DataBlob *privKeyData)
232 {
233     OH_Crypto_FreeDataBlob(pubKeyData);
234     OH_Crypto_FreeDataBlob(privKeyData);
235 }
236 
FreeEccKeyParams(Crypto_DataBlob * pubKeyXData,Crypto_DataBlob * pubKeyYData,Crypto_DataBlob * privKeyData)237 static void FreeEccKeyParams(Crypto_DataBlob *pubKeyXData, Crypto_DataBlob *pubKeyYData, Crypto_DataBlob *privKeyData)
238 {
239     OH_Crypto_FreeDataBlob(pubKeyXData);
240     OH_Crypto_FreeDataBlob(pubKeyYData);
241     OH_Crypto_FreeDataBlob(privKeyData);
242 }
243 
FreeDhCommonParams(Crypto_DataBlob * pData,Crypto_DataBlob * gData,Crypto_DataBlob * lData)244 static void FreeDhCommonParams(Crypto_DataBlob *pData, Crypto_DataBlob *gData, Crypto_DataBlob *lData)
245 {
246     OH_Crypto_FreeDataBlob(pData);
247     OH_Crypto_FreeDataBlob(gData);
248     OH_Crypto_FreeDataBlob(lData);
249 }
250 
FreeEccCommonParams(Crypto_DataBlob * pData,Crypto_DataBlob * aData,Crypto_DataBlob * bData,Crypto_DataBlob * gxData,Crypto_DataBlob * gyData,Crypto_DataBlob * nData,Crypto_DataBlob * hData)251 static void FreeEccCommonParams(Crypto_DataBlob *pData, Crypto_DataBlob *aData, Crypto_DataBlob *bData,
252                                 Crypto_DataBlob *gxData, Crypto_DataBlob *gyData, Crypto_DataBlob *nData,
253                                 Crypto_DataBlob *hData)
254 {
255     OH_Crypto_FreeDataBlob(pData);
256     OH_Crypto_FreeDataBlob(aData);
257     OH_Crypto_FreeDataBlob(bData);
258     OH_Crypto_FreeDataBlob(gxData);
259     OH_Crypto_FreeDataBlob(gyData);
260     OH_Crypto_FreeDataBlob(nData);
261     OH_Crypto_FreeDataBlob(hData);
262 }
263 
264 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest001, TestSize.Level0)
265 {
266     OH_CryptoAsymKeyGenerator *generator = nullptr;
267     OH_CryptoKeyPair *keyCtx = nullptr;
268     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("DSA2048", &generator);
269     EXPECT_EQ(ret, CRYPTO_SUCCESS);
270     ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx);
271     EXPECT_EQ(ret, CRYPTO_SUCCESS);
272 
273     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(generator);
274     ASSERT_NE(algoName, nullptr);
275 
276     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
277 
278     Crypto_DataBlob dataBlob = {.data = nullptr, .len = 0};
279     ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_Q_DATABLOB, &dataBlob);
280     EXPECT_EQ(ret, CRYPTO_SUCCESS);
281     ASSERT_NE(dataBlob.data, nullptr);
282     ASSERT_NE(dataBlob.len, 0);
283     HcfFree(dataBlob.data);
284     OH_CryptoKeyPair_Destroy(keyCtx);
285     OH_CryptoAsymKeyGenerator_Destroy(generator);
286 }
287 
288 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest002, TestSize.Level0)
289 {
290     OH_CryptoAsymKeyGenerator *generator = nullptr;
291     OH_Crypto_ErrCode res = OH_CryptoAsymKeyGenerator_Create("RSA512", &generator);
292     EXPECT_EQ(res, CRYPTO_SUCCESS);
293     EXPECT_NE(generator, nullptr);
294 
295     OH_CryptoKeyPair *dupKeyPair = nullptr;
296     Crypto_DataBlob pubKeyX509Str = {};
297     pubKeyX509Str.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testPubkeyX509Str512.c_str()));
298     pubKeyX509Str.len = strlen(g_testPubkeyX509Str512.c_str());
299 
300     Crypto_DataBlob pubKeyPkcs1Str = {};
301     pubKeyPkcs1Str.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testPubkeyPkcs1Str512.c_str()));
302     pubKeyPkcs1Str.len = strlen(g_testPubkeyPkcs1Str512.c_str());
303     res = OH_CryptoAsymKeyGenerator_Convert(generator, CRYPTO_PEM, &pubKeyX509Str, nullptr, &dupKeyPair);
304     EXPECT_EQ(res, CRYPTO_SUCCESS);
305 
306     OH_CryptoPubKey *pubkey = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
307     Crypto_DataBlob retBlob = {.data = nullptr, .len = 0};
308     res = OH_CryptoPubKey_Encode(pubkey, CRYPTO_PEM, "PKCS1", &retBlob);
309     EXPECT_EQ(res, CRYPTO_SUCCESS);
310     int32_t cmpRes =
311         strcmp(reinterpret_cast<const char *>(retBlob.data), reinterpret_cast<const char *>(pubKeyPkcs1Str.data));
312     EXPECT_EQ(cmpRes, CRYPTO_SUCCESS);
313 
314     Crypto_DataBlob retBlobX509 = {.data = nullptr, .len = 0};
315     res = OH_CryptoPubKey_Encode(pubkey, CRYPTO_PEM, "X509", &retBlobX509);
316     EXPECT_EQ(res, CRYPTO_SUCCESS);
317     cmpRes =
318         strcmp(reinterpret_cast<const char *>(retBlobX509.data), reinterpret_cast<const char *>(pubKeyX509Str.data));
319     EXPECT_EQ(cmpRes, CRYPTO_SUCCESS);
320 
321     OH_Crypto_FreeDataBlob(&retBlob);
322     OH_Crypto_FreeDataBlob(&retBlobX509);
323     OH_CryptoKeyPair_Destroy(dupKeyPair);
324     OH_CryptoAsymKeyGenerator_Destroy(generator);
325 }
326 
327 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest003, TestSize.Level0)
328 {
329     OH_CryptoAsymKeyGenerator *generator = nullptr;
330     OH_CryptoKeyPair *keyCtx = nullptr;
331     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("RSA768", &generator);
332     EXPECT_EQ(ret, CRYPTO_SUCCESS);
333     ret = OH_CryptoAsymKeyGenerator_Generate(generator, &keyCtx);
334     EXPECT_EQ(ret, CRYPTO_SUCCESS);
335 
336     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyCtx);
337     Crypto_DataBlob dataBlobE = {.data = nullptr, .len = 0};
338     ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, &dataBlobE);
339     EXPECT_EQ(ret, CRYPTO_SUCCESS);
340     ASSERT_NE(dataBlobE.data, nullptr);
341     ASSERT_NE(dataBlobE.len, 0);
342     HcfFree(dataBlobE.data);
343     OH_CryptoKeyPair_Destroy(keyCtx);
344     OH_CryptoAsymKeyGenerator_Destroy(generator);
345 }
346 
347 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest004, TestSize.Level0)
348 {
349     OH_CryptoAsymKeyGenerator *ctx = nullptr;
350     OH_CryptoKeyPair *keyPair = nullptr;
351     OH_Crypto_ErrCode ret;
352 
353     ret = OH_CryptoAsymKeyGenerator_Create("RSA512|PRIMES_2", &ctx);
354     ASSERT_EQ(ret, CRYPTO_SUCCESS);
355 
356     ret = OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair);
357     ASSERT_EQ(ret, CRYPTO_SUCCESS);
358 
359     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(ctx);
360     EXPECT_NE(algoName, nullptr);
361 
362     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
363     ASSERT_EQ(ret, CRYPTO_SUCCESS);
364 
365     Crypto_DataBlob retBlob = {.data = nullptr, .len = 0};
366     ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_PEM, "PKCS1", &retBlob);
367     ASSERT_EQ(ret, CRYPTO_SUCCESS);
368 
369     OH_CryptoKeyPair *dupKeyPair = nullptr;
370     ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_PEM, &retBlob, nullptr, &dupKeyPair);
371     ASSERT_EQ(ret, CRYPTO_SUCCESS);
372 
373     OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
374     ASSERT_EQ(ret, CRYPTO_SUCCESS);
375     Crypto_DataBlob dataBlob = {.data = nullptr, .len = 0};
376 
377     ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_RSA_N_DATABLOB, &dataBlob);
378     ASSERT_EQ(ret, CRYPTO_SUCCESS);
379     ASSERT_NE(dataBlob.data, nullptr);
380     ASSERT_NE(dataBlob.len, 0);
381     OH_Crypto_FreeDataBlob(&dataBlob);
382 
383     OH_CryptoAsymKeyGenerator_Destroy(ctx);
384     OH_CryptoKeyPair_Destroy(keyPair);
385     OH_Crypto_FreeDataBlob(&retBlob);
386     OH_CryptoKeyPair_Destroy(dupKeyPair);
387 }
388 
389 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest005, TestSize.Level0)
390 {
391     OH_CryptoAsymKeyGenerator *ctx = nullptr;
392     OH_CryptoKeyPair *keyPair = nullptr;
393     OH_Crypto_ErrCode ret;
394 
395     ret = OH_CryptoAsymKeyGenerator_Create("Ed25519", &ctx);
396     ASSERT_EQ(ret, CRYPTO_SUCCESS);
397 
398     ret = OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair);
399     ASSERT_EQ(ret, CRYPTO_SUCCESS);
400 
401     const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(ctx);
402     EXPECT_NE(algoName, nullptr);
403 
404     OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
405     ASSERT_EQ(ret, CRYPTO_SUCCESS);
406 
407     Crypto_DataBlob retBlob = {.data = nullptr, .len = 0};
408     ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, nullptr, &retBlob);
409     ASSERT_EQ(ret, CRYPTO_SUCCESS);
410 
411     OH_CryptoKeyPair *dupKeyPair = nullptr;
412     ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &retBlob, nullptr, &dupKeyPair);
413     ASSERT_EQ(ret, CRYPTO_SUCCESS);
414 
415     OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
416     ASSERT_EQ(ret, CRYPTO_SUCCESS);
417     Crypto_DataBlob dataBlob = {.data = nullptr, .len = 0};
418 
419     ret = OH_CryptoPubKey_GetParam(pubKey1, CRYPTO_ED25519_PK_DATABLOB, &dataBlob);
420     ASSERT_EQ(ret, CRYPTO_SUCCESS);
421     ASSERT_NE(dataBlob.data, nullptr);
422     ASSERT_NE(dataBlob.len, 0);
423     OH_Crypto_FreeDataBlob(&dataBlob);
424     OH_Crypto_FreeDataBlob(&retBlob);
425 
426     OH_CryptoAsymKeyGenerator_Destroy(ctx);
427     OH_CryptoKeyPair_Destroy(keyPair);
428     OH_CryptoKeyPair_Destroy(dupKeyPair);
429 }
430 
431 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest006, TestSize.Level0)
432 {
433     OH_CryptoAsymKeyGenerator *keyGen = nullptr;
434     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("RSA2048", &keyGen);
435     EXPECT_EQ(ret, CRYPTO_SUCCESS);
436     ASSERT_NE(keyGen, nullptr);
437 
438     OH_CryptoKeyPair *keyPair = nullptr;
439     ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
440     EXPECT_EQ(ret, CRYPTO_SUCCESS);
441     ASSERT_NE(keyPair, nullptr);
442 
443     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
444     ASSERT_NE(privKey, nullptr);
445 
446     OH_CryptoPrivKeyEncodingParams *params = nullptr;
447     ret = OH_CryptoPrivKeyEncodingParams_Create(&params);
448     EXPECT_EQ(ret, CRYPTO_SUCCESS);
449     ASSERT_NE(params, nullptr);
450 
451     Crypto_DataBlob password = {(uint8_t *)"1234567890", 10};
452     Crypto_DataBlob cipher = {(uint8_t *)"AES-128-CBC", 11};
453     ret = OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_PASSWORD_STR, &password);
454     EXPECT_EQ(ret, CRYPTO_SUCCESS);
455     ret = OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_SYMMETRIC_CIPHER_STR, &cipher);
456     EXPECT_EQ(ret, CRYPTO_SUCCESS);
457 
458     Crypto_DataBlob pemData = {0};
459     ret = OH_CryptoPrivKey_Encode(privKey, CRYPTO_PEM, "PKCS8", nullptr, &pemData);
460     EXPECT_EQ(ret, CRYPTO_SUCCESS);
461     OH_Crypto_FreeDataBlob(&pemData);
462 
463     ret = OH_CryptoPrivKey_Encode(privKey, CRYPTO_PEM, "PKCS8", params, &pemData);
464     EXPECT_EQ(ret, CRYPTO_SUCCESS);
465     ret = OH_CryptoAsymKeyGenerator_SetPassword(keyGen, password.data, password.len);
466     EXPECT_EQ(ret, CRYPTO_SUCCESS);
467     OH_CryptoKeyPair *keyCtx = nullptr;
468     ret = OH_CryptoAsymKeyGenerator_Convert(keyGen, CRYPTO_PEM, nullptr, &pemData, &keyCtx);
469     EXPECT_EQ(ret, CRYPTO_SUCCESS);
470     OH_CryptoKeyPair_Destroy(keyCtx);
471 
472     Crypto_DataBlob n = {0};
473     Crypto_DataBlob d = {0};
474     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_RSA_N_DATABLOB, &n);
475     EXPECT_EQ(ret, CRYPTO_SUCCESS);
476     ret = OH_CryptoPrivKey_GetParam(privKey, CRYPTO_RSA_D_DATABLOB, &d);
477     EXPECT_EQ(ret, CRYPTO_SUCCESS);
478 
479     OH_Crypto_FreeDataBlob(&pemData);
480     OH_Crypto_FreeDataBlob(&n);
481     OH_Crypto_FreeDataBlob(&d);
482     OH_CryptoPrivKeyEncodingParams_Destroy(params);
483     OH_CryptoKeyPair_Destroy(keyPair);
484     OH_CryptoAsymKeyGenerator_Destroy(keyGen);
485 }
486 
487 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest007, TestSize.Level0)
488 {
489     OH_CryptoAsymKeyGenerator *keyGen = nullptr;
490     OH_Crypto_ErrCode ret = OH_CryptoAsymKeyGenerator_Create("ECC224", &keyGen);
491     EXPECT_EQ(ret, CRYPTO_SUCCESS);
492     ASSERT_NE(keyGen, nullptr);
493 
494     OH_CryptoKeyPair *keyPair = nullptr;
495     ret = OH_CryptoAsymKeyGenerator_Generate(keyGen, &keyPair);
496     EXPECT_EQ(ret, CRYPTO_SUCCESS);
497     ASSERT_NE(keyPair, nullptr);
498 
499     OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
500     ASSERT_NE(privKey, nullptr);
501 
502     Crypto_DataBlob derData = {0};
503     ret = OH_CryptoPrivKey_Encode(nullptr, CRYPTO_DER, "PKCS8", nullptr, &derData);
504     EXPECT_NE(ret, CRYPTO_SUCCESS);
505     ret = OH_CryptoPrivKey_Encode(privKey, CRYPTO_DER, "PKCS8", nullptr, nullptr);
506     EXPECT_NE(ret, CRYPTO_SUCCESS);
507 
508     ret = OH_CryptoPrivKey_Encode(privKey, CRYPTO_DER, "PKCS8", nullptr, &derData);
509     EXPECT_EQ(ret, CRYPTO_SUCCESS);
510     ASSERT_NE(derData.data, nullptr);
511     ASSERT_NE(derData.len, 0);
512     OH_Crypto_FreeDataBlob(&derData);
513 
514     ret = OH_CryptoPrivKey_Encode(privKey, CRYPTO_DER, nullptr, nullptr, &derData);
515     EXPECT_EQ(ret, CRYPTO_SUCCESS);
516     ASSERT_NE(derData.data, nullptr);
517     ASSERT_NE(derData.len, 0);
518     OH_Crypto_FreeDataBlob(&derData);
519 
520     OH_CryptoKeyPair_Destroy(keyPair);
521     OH_CryptoAsymKeyGenerator_Destroy(keyGen);
522 }
523 
524 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest008, TestSize.Level0)
525 {
526     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DSA2048");
527     ASSERT_NE(keyCtx, nullptr);
528     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
529     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
530     Crypto_DataBlob pData = {.data = nullptr, .len = 0};
531     Crypto_DataBlob qData = {.data = nullptr, .len = 0};
532     Crypto_DataBlob gData = {.data = nullptr, .len = 0};
533     OH_Crypto_ErrCode ret = GetDsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &pData, &qData, &gData);
534     EXPECT_EQ(ret, CRYPTO_SUCCESS);
535 
536     OH_CryptoAsymKeySpec *keySpec = nullptr;
537     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
538     EXPECT_EQ(ret, CRYPTO_SUCCESS);
539     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
540     EXPECT_EQ(ret, CRYPTO_SUCCESS);
541     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
542     EXPECT_EQ(ret, CRYPTO_SUCCESS);
543     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
544     EXPECT_EQ(ret, CRYPTO_SUCCESS);
545     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
546     EXPECT_EQ(ret, CRYPTO_SUCCESS);
547     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
548     EXPECT_EQ(ret, CRYPTO_SUCCESS);
549     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
550     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
551     EXPECT_EQ(ret, CRYPTO_SUCCESS);
552     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
553     EXPECT_EQ(ret, CRYPTO_SUCCESS);
554     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
555     EXPECT_EQ(ret, CRYPTO_SUCCESS);
556     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
557     EXPECT_EQ(ret, CRYPTO_SUCCESS);
558     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
559     EXPECT_EQ(ret, CRYPTO_SUCCESS);
560     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
561 
562     OH_CryptoKeyPair *keyPair = nullptr;
563     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
564     EXPECT_EQ(ret, CRYPTO_SUCCESS);
565     ASSERT_NE(keyPair, nullptr);
566     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
567     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
568     OH_CryptoKeyPair_Destroy(keyPair);
569     OH_CryptoAsymKeySpec_Destroy(keySpec);
570     OH_CryptoKeyPair_Destroy(keyCtx);
571 }
572 
573 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest009, TestSize.Level0)
574 {
575     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DSA2048");
576     ASSERT_NE(keyCtx, nullptr);
577     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
578     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
579     Crypto_DataBlob pData = {.data = nullptr, .len = 0};
580     Crypto_DataBlob qData = {.data = nullptr, .len = 0};
581     Crypto_DataBlob gData = {.data = nullptr, .len = 0};
582     OH_Crypto_ErrCode ret = GetDsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &pData, &qData, &gData);
583     EXPECT_EQ(ret, CRYPTO_SUCCESS);
584 
585     OH_CryptoAsymKeySpec *keySpec = nullptr;
586     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &keySpec);
587     EXPECT_EQ(ret, CRYPTO_SUCCESS);
588     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
589     EXPECT_EQ(ret, CRYPTO_SUCCESS);
590     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
591     EXPECT_NE(ret, CRYPTO_SUCCESS);
592     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
593     EXPECT_EQ(ret, CRYPTO_SUCCESS);
594     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
595     EXPECT_EQ(ret, CRYPTO_SUCCESS);
596     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
597     EXPECT_EQ(ret, CRYPTO_SUCCESS);
598     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
599     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
600     EXPECT_EQ(ret, CRYPTO_SUCCESS);
601     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
602     EXPECT_NE(ret, CRYPTO_SUCCESS);
603     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
604     EXPECT_EQ(ret, CRYPTO_SUCCESS);
605     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
606     EXPECT_EQ(ret, CRYPTO_SUCCESS);
607     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
608     EXPECT_EQ(ret, CRYPTO_SUCCESS);
609     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
610 
611     OH_CryptoKeyPair *keyPair = nullptr;
612     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
613     EXPECT_EQ(ret, CRYPTO_SUCCESS);
614     ASSERT_NE(keyPair, nullptr);
615     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
616     ASSERT_EQ(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
617 
618     OH_CryptoKeyPair_Destroy(keyPair);
619     OH_CryptoAsymKeySpec_Destroy(keySpec);
620     OH_CryptoKeyPair_Destroy(keyCtx);
621 }
622 
623 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest010, TestSize.Level0)
624 {
625     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DSA2048");
626     ASSERT_NE(keyCtx, nullptr);
627     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
628     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
629     Crypto_DataBlob pData = {.data = nullptr, .len = 0};
630     Crypto_DataBlob qData = {.data = nullptr, .len = 0};
631     Crypto_DataBlob gData = {.data = nullptr, .len = 0};
632     OH_Crypto_ErrCode ret = GetDsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &pData, &qData, &gData);
633     EXPECT_EQ(ret, CRYPTO_SUCCESS);
634 
635     OH_CryptoAsymKeySpec *keySpec = nullptr;
636     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &keySpec);
637     EXPECT_NE(ret, CRYPTO_SUCCESS);
638     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec);
639     EXPECT_EQ(ret, CRYPTO_SUCCESS);
640     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
641     EXPECT_NE(ret, CRYPTO_SUCCESS);
642     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
643     EXPECT_NE(ret, CRYPTO_SUCCESS);
644     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
645     EXPECT_EQ(ret, CRYPTO_SUCCESS);
646     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
647     EXPECT_EQ(ret, CRYPTO_SUCCESS);
648     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
649     EXPECT_EQ(ret, CRYPTO_SUCCESS);
650     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
651     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
652     EXPECT_NE(ret, CRYPTO_SUCCESS);
653     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
654     EXPECT_NE(ret, CRYPTO_SUCCESS);
655     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_P_DATABLOB, &pData);
656     EXPECT_EQ(ret, CRYPTO_SUCCESS);
657     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_Q_DATABLOB, &qData);
658     EXPECT_EQ(ret, CRYPTO_SUCCESS);
659     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DSA_G_DATABLOB, &gData);
660     EXPECT_EQ(ret, CRYPTO_SUCCESS);
661     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
662 
663     OH_CryptoKeyPair *keyPair = nullptr;
664     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
665     EXPECT_EQ(ret, CRYPTO_SUCCESS);
666     ASSERT_NE(keyPair, nullptr);
667     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
668     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
669 
670     OH_CryptoKeyPair_Destroy(keyPair);
671     OH_CryptoAsymKeySpec_Destroy(keySpec);
672     OH_CryptoKeyPair_Destroy(keyCtx);
673 }
674 
675 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest011, TestSize.Level0)
676 {
677     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("RSA2048");
678     ASSERT_NE(keyCtx, nullptr);
679     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
680     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
681     Crypto_DataBlob nData = {.data = nullptr, .len = 0};
682     OH_Crypto_ErrCode ret = GetRsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &nData);
683     EXPECT_EQ(ret, CRYPTO_SUCCESS);
684 
685     OH_CryptoAsymKeySpec *keySpec = nullptr;
686     ret = OH_CryptoAsymKeySpec_Create("RSA", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
687     EXPECT_EQ(ret, CRYPTO_SUCCESS);
688     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_E_DATABLOB, &pubKeyData);
689     EXPECT_EQ(ret, CRYPTO_SUCCESS);
690     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_D_DATABLOB, &privKeyData);
691     EXPECT_EQ(ret, CRYPTO_SUCCESS);
692     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_N_DATABLOB, &nData);
693     EXPECT_EQ(ret, CRYPTO_SUCCESS);
694     FreeRsaKeyParams(&pubKeyData, &privKeyData, &nData);
695     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_E_DATABLOB, &pubKeyData);
696     EXPECT_EQ(ret, CRYPTO_SUCCESS);
697     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_D_DATABLOB, &privKeyData);
698     EXPECT_EQ(ret, CRYPTO_SUCCESS);
699     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_N_DATABLOB, &nData);
700     EXPECT_EQ(ret, CRYPTO_SUCCESS);
701     FreeRsaKeyParams(&pubKeyData, &privKeyData, &nData);
702 
703     OH_CryptoKeyPair *keyPair = nullptr;
704     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
705     EXPECT_EQ(ret, CRYPTO_SUCCESS);
706     ASSERT_NE(keyPair, nullptr);
707     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
708     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
709     OH_CryptoKeyPair_Destroy(keyPair);
710     OH_CryptoAsymKeySpec_Destroy(keySpec);
711     OH_CryptoKeyPair_Destroy(keyCtx);
712 }
713 
714 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest012, TestSize.Level0)
715 {
716     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("RSA2048");
717     ASSERT_NE(keyCtx, nullptr);
718     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
719     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
720     Crypto_DataBlob nData = {.data = nullptr, .len = 0};
721     OH_Crypto_ErrCode ret = GetRsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &nData);
722     EXPECT_EQ(ret, CRYPTO_SUCCESS);
723 
724     OH_CryptoAsymKeySpec *keySpec = nullptr;
725     ret = OH_CryptoAsymKeySpec_Create("RSA", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &keySpec);
726     EXPECT_EQ(ret, CRYPTO_SUCCESS);
727     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_E_DATABLOB, &pubKeyData);
728     EXPECT_EQ(ret, CRYPTO_SUCCESS);
729     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_D_DATABLOB, &privKeyData);
730     EXPECT_NE(ret, CRYPTO_SUCCESS);
731     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_RSA_N_DATABLOB, &nData);
732     EXPECT_EQ(ret, CRYPTO_SUCCESS);
733     FreeRsaKeyParams(&pubKeyData, &privKeyData, &nData);
734     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_E_DATABLOB, &pubKeyData);
735     EXPECT_EQ(ret, CRYPTO_SUCCESS);
736     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_D_DATABLOB, &privKeyData);
737     EXPECT_NE(ret, CRYPTO_SUCCESS);
738     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_RSA_N_DATABLOB, &nData);
739     EXPECT_EQ(ret, CRYPTO_SUCCESS);
740     FreeRsaKeyParams(&pubKeyData, &privKeyData, &nData);
741 
742     OH_CryptoKeyPair *keyPair = nullptr;
743     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
744     EXPECT_EQ(ret, CRYPTO_SUCCESS);
745     ASSERT_NE(keyPair, nullptr);
746     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
747     EXPECT_EQ(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
748 
749     OH_CryptoKeyPair_Destroy(keyPair);
750     OH_CryptoAsymKeySpec_Destroy(keySpec);
751     OH_CryptoKeyPair_Destroy(keyCtx);
752 }
753 
754 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest013, TestSize.Level0)
755 {
756     OH_CryptoAsymKeySpec *keySpec = nullptr;
757     OH_Crypto_ErrCode ret = OH_CryptoAsymKeySpec_Create("RSA", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &keySpec);
758     ASSERT_NE(ret, CRYPTO_SUCCESS);
759     ret = OH_CryptoAsymKeySpec_Create("RSA", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec);
760     ASSERT_NE(ret, CRYPTO_SUCCESS);
761 }
762 
763 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest014, TestSize.Level0)
764 {
765     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DH_modp2048");
766     ASSERT_NE(keyCtx, nullptr);
767     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
768     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
769     OH_Crypto_ErrCode ret = GetDhKeyParams(keyCtx, &pubKeyData, &privKeyData);
770     EXPECT_EQ(ret, CRYPTO_SUCCESS);
771 
772     OH_CryptoAsymKeySpec *dhCommonSpec = nullptr;
773     ret = OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(2048, 1024, &dhCommonSpec);
774     EXPECT_EQ(ret, CRYPTO_SUCCESS);
775     OH_CryptoAsymKeySpec *keySpec = nullptr;
776     ret = OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
777     EXPECT_EQ(ret, CRYPTO_SUCCESS);
778     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, dhCommonSpec);
779     EXPECT_EQ(ret, CRYPTO_SUCCESS);
780     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
781     EXPECT_EQ(ret, CRYPTO_SUCCESS);
782     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
783     EXPECT_EQ(ret, CRYPTO_SUCCESS);
784     FreeDhKeyParams(&pubKeyData, &privKeyData);
785     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
786     EXPECT_EQ(ret, CRYPTO_SUCCESS);
787     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
788     EXPECT_EQ(ret, CRYPTO_SUCCESS);
789     FreeDhKeyParams(&pubKeyData, &privKeyData);
790 
791     OH_CryptoKeyPair *keyPair = nullptr;
792     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
793     EXPECT_EQ(ret, CRYPTO_SUCCESS);
794     ASSERT_NE(keyPair, nullptr);
795     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
796     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
797 
798     OH_CryptoKeyPair_Destroy(keyPair);
799     OH_CryptoAsymKeySpec_Destroy(keySpec);
800     OH_CryptoAsymKeySpec_Destroy(dhCommonSpec);
801     OH_CryptoKeyPair_Destroy(keyCtx);
802 }
803 
804 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest015, TestSize.Level0)
805 {
806     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DH_modp2048");
807     ASSERT_NE(keyCtx, nullptr);
808     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
809     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
810     OH_Crypto_ErrCode ret = GetDhKeyParams(keyCtx, &pubKeyData, &privKeyData);
811     EXPECT_EQ(ret, CRYPTO_SUCCESS);
812 
813     OH_CryptoAsymKeySpec *dhCommonSpec = nullptr;
814     ret = OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(2048, 1024, &dhCommonSpec);
815     EXPECT_EQ(ret, CRYPTO_SUCCESS);
816     OH_CryptoAsymKeySpec *keySpec = nullptr;
817     ret = OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &keySpec);
818     EXPECT_EQ(ret, CRYPTO_SUCCESS);
819     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, dhCommonSpec);
820     EXPECT_EQ(ret, CRYPTO_SUCCESS);
821     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
822     EXPECT_EQ(ret, CRYPTO_SUCCESS);
823     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
824     EXPECT_NE(ret, CRYPTO_SUCCESS);
825     FreeDhKeyParams(&pubKeyData, &privKeyData);
826     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
827     EXPECT_EQ(ret, CRYPTO_SUCCESS);
828     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
829     EXPECT_NE(ret, CRYPTO_SUCCESS);
830     FreeDhKeyParams(&pubKeyData, &privKeyData);
831 
832     OH_CryptoKeyPair *keyPair = nullptr;
833     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
834     EXPECT_EQ(ret, CRYPTO_SUCCESS);
835     ASSERT_NE(keyPair, nullptr);
836     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
837     EXPECT_EQ(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
838 
839     OH_CryptoKeyPair_Destroy(keyPair);
840     OH_CryptoAsymKeySpec_Destroy(keySpec);
841     OH_CryptoAsymKeySpec_Destroy(dhCommonSpec);
842     OH_CryptoKeyPair_Destroy(keyCtx);
843 }
844 
845 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest016, TestSize.Level0)
846 {
847     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DH_modp2048");
848     ASSERT_NE(keyCtx, nullptr);
849     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
850     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
851     OH_Crypto_ErrCode ret = GetDhKeyParams(keyCtx, &pubKeyData, &privKeyData);
852     EXPECT_EQ(ret, CRYPTO_SUCCESS);
853 
854     OH_CryptoAsymKeySpec *dhCommonSpec = nullptr;
855     ret = OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(2048, 1024, &dhCommonSpec);
856     EXPECT_EQ(ret, CRYPTO_SUCCESS);
857     OH_CryptoAsymKeySpec *keySpec = nullptr;
858     ret = OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &keySpec);
859     EXPECT_EQ(ret, CRYPTO_SUCCESS);
860     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, dhCommonSpec);
861     EXPECT_EQ(ret, CRYPTO_SUCCESS);
862     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
863     EXPECT_NE(ret, CRYPTO_SUCCESS);
864     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
865     EXPECT_EQ(ret, CRYPTO_SUCCESS);
866     FreeDhKeyParams(&pubKeyData, &privKeyData);
867     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_PK_DATABLOB, &pubKeyData);
868     EXPECT_NE(ret, CRYPTO_SUCCESS);
869     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_SK_DATABLOB, &privKeyData);
870     EXPECT_EQ(ret, CRYPTO_SUCCESS);
871     FreeDhKeyParams(&pubKeyData, &privKeyData);
872 
873     OH_CryptoKeyPair *keyPair = nullptr;
874     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
875     EXPECT_EQ(ret, CRYPTO_SUCCESS);
876     ASSERT_NE(keyPair, nullptr);
877     EXPECT_EQ(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
878     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
879 
880     OH_CryptoKeyPair_Destroy(keyPair);
881     OH_CryptoAsymKeySpec_Destroy(keySpec);
882     OH_CryptoAsymKeySpec_Destroy(dhCommonSpec);
883     OH_CryptoKeyPair_Destroy(keyCtx);
884 }
885 
886 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest017, TestSize.Level0)
887 {
888     OH_CryptoAsymKeySpec *dhCommonSpec = nullptr;
889     OH_Crypto_ErrCode ret = OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(2048, 1024, &dhCommonSpec);
890     EXPECT_EQ(ret, CRYPTO_SUCCESS);
891     OH_CryptoAsymKeySpec *keySpec = nullptr;
892     ret = OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec);
893     EXPECT_EQ(ret, CRYPTO_SUCCESS);
894     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, dhCommonSpec);
895     EXPECT_EQ(ret, CRYPTO_SUCCESS);
896 
897     Crypto_DataBlob p = {0};
898     Crypto_DataBlob g = {0};
899     Crypto_DataBlob l = {0};
900     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_P_DATABLOB, &p);
901     EXPECT_EQ(ret, CRYPTO_SUCCESS);
902     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_G_DATABLOB, &g);
903     EXPECT_EQ(ret, CRYPTO_SUCCESS);
904     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_DH_L_INT, &l);
905     EXPECT_EQ(ret, CRYPTO_SUCCESS);
906     FreeDhCommonParams(&p, &g, &l);
907 
908     OH_CryptoKeyPair *keyPair = nullptr;
909     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
910     EXPECT_EQ(ret, CRYPTO_SUCCESS);
911     ASSERT_NE(keyPair, nullptr);
912     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
913     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
914 
915     OH_CryptoKeyPair_Destroy(keyPair);
916     OH_CryptoAsymKeySpec_Destroy(dhCommonSpec);
917     OH_CryptoAsymKeySpec_Destroy(keySpec);
918 }
919 
920 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest018, TestSize.Level0)
921 {
922     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("X25519");
923     ASSERT_NE(keyCtx, nullptr);
924     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
925     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
926     OH_Crypto_ErrCode ret = GetX25519KeyParams(keyCtx, &pubKeyData, &privKeyData);
927     EXPECT_EQ(ret, CRYPTO_SUCCESS);
928 
929     OH_CryptoAsymKeySpec *keySpec = nullptr;
930     ret = OH_CryptoAsymKeySpec_Create("X25519", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
931     EXPECT_EQ(ret, CRYPTO_SUCCESS);
932     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
933     EXPECT_EQ(ret, CRYPTO_SUCCESS);
934     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
935     EXPECT_EQ(ret, CRYPTO_SUCCESS);
936     FreeX25519KeyParams(&pubKeyData, &privKeyData);
937     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
938     EXPECT_EQ(ret, CRYPTO_SUCCESS);
939     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
940     EXPECT_EQ(ret, CRYPTO_SUCCESS);
941     FreeX25519KeyParams(&pubKeyData, &privKeyData);
942 
943     OH_CryptoKeyPair *keyPair = nullptr;
944     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
945     EXPECT_EQ(ret, CRYPTO_SUCCESS);
946     ASSERT_NE(keyPair, nullptr);
947     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
948     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
949     OH_CryptoKeyPair_Destroy(keyPair);
950     OH_CryptoAsymKeySpec_Destroy(keySpec);
951     OH_CryptoKeyPair_Destroy(keyCtx);
952 }
953 
954 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest019, TestSize.Level0)
955 {
956     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("X25519");
957     ASSERT_NE(keyCtx, nullptr);
958     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
959     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
960     OH_Crypto_ErrCode ret = GetX25519KeyParams(keyCtx, &pubKeyData, &privKeyData);
961     EXPECT_EQ(ret, CRYPTO_SUCCESS);
962 
963     OH_CryptoAsymKeySpec *keySpec = nullptr;
964     ret = OH_CryptoAsymKeySpec_Create("X25519", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &keySpec);
965     EXPECT_EQ(ret, CRYPTO_SUCCESS);
966     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
967     EXPECT_EQ(ret, CRYPTO_SUCCESS);
968     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
969     EXPECT_NE(ret, CRYPTO_SUCCESS);
970     FreeX25519KeyParams(&pubKeyData, &privKeyData);
971     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
972     EXPECT_EQ(ret, CRYPTO_SUCCESS);
973     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
974     EXPECT_NE(ret, CRYPTO_SUCCESS);
975     FreeX25519KeyParams(&pubKeyData, &privKeyData);
976 
977     OH_CryptoKeyPair *keyPair = nullptr;
978     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
979     EXPECT_EQ(ret, CRYPTO_SUCCESS);
980     ASSERT_NE(keyPair, nullptr);
981     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
982     EXPECT_EQ(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
983 
984     OH_CryptoKeyPair_Destroy(keyPair);
985     OH_CryptoAsymKeySpec_Destroy(keySpec);
986     OH_CryptoKeyPair_Destroy(keyCtx);
987 }
988 
989 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest020, TestSize.Level0)
990 {
991     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("X25519");
992     ASSERT_NE(keyCtx, nullptr);
993     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
994     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
995     OH_Crypto_ErrCode ret = GetX25519KeyParams(keyCtx, &pubKeyData, &privKeyData);
996     EXPECT_EQ(ret, CRYPTO_SUCCESS);
997 
998     OH_CryptoAsymKeySpec *keySpec = nullptr;
999     ret = OH_CryptoAsymKeySpec_Create("X25519", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &keySpec);
1000     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1001     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
1002     EXPECT_NE(ret, CRYPTO_SUCCESS);
1003     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
1004     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1005     FreeX25519KeyParams(&pubKeyData, &privKeyData);
1006     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_PK_DATABLOB, &pubKeyData);
1007     EXPECT_NE(ret, CRYPTO_SUCCESS);
1008     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_X25519_SK_DATABLOB, &privKeyData);
1009     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1010     FreeX25519KeyParams(&pubKeyData, &privKeyData);
1011 
1012     OH_CryptoKeyPair *keyPair = nullptr;
1013     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1014     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1015     ASSERT_NE(keyPair, nullptr);
1016     EXPECT_EQ(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1017     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1018 
1019     OH_CryptoKeyPair_Destroy(keyPair);
1020     OH_CryptoAsymKeySpec_Destroy(keySpec);
1021     OH_CryptoKeyPair_Destroy(keyCtx);
1022 }
1023 
1024 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest021, TestSize.Level0)
1025 {
1026     OH_CryptoAsymKeySpec *keySpec = nullptr;
1027     OH_Crypto_ErrCode ret = OH_CryptoAsymKeySpec_Create("X25519", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec);
1028     EXPECT_NE(ret, CRYPTO_SUCCESS);
1029     OH_CryptoAsymKeySpec_Destroy(keySpec);
1030 }
1031 
1032 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest022, TestSize.Level0)
1033 {
1034     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("ECC_BrainPoolP384r1");
1035     ASSERT_NE(keyCtx, nullptr);
1036     Crypto_DataBlob pubKeyXData = {.data = nullptr, .len = 0};
1037     Crypto_DataBlob pubKeyYData = {.data = nullptr, .len = 0};
1038     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
1039     OH_Crypto_ErrCode ret = GetEccKeyParams(keyCtx, &pubKeyXData, &pubKeyYData, &privKeyData);
1040     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1041 
1042     OH_CryptoAsymKeySpec *ecCommonSpec = nullptr;
1043     ret = OH_CryptoAsymKeySpec_GenEcCommonParamsSpec("NID_brainpoolP384r1", &ecCommonSpec);
1044     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1045     OH_CryptoAsymKeySpec *keySpec = nullptr;
1046     ret = OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
1047     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1048     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, ecCommonSpec);
1049     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1050     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1051     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1052     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1053     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1054     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1055     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1056     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1057     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1058     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1059     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1060     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1061     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1062     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1063     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1064 
1065     OH_CryptoKeyPair *keyPair = nullptr;
1066     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1067     // 输入使用大端时会校验成功
1068     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1069     ASSERT_NE(keyPair, nullptr);
1070     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1071     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1072 
1073     OH_CryptoKeyPair_Destroy(keyPair);
1074     OH_CryptoAsymKeySpec_Destroy(keySpec);
1075     OH_CryptoAsymKeySpec_Destroy(ecCommonSpec);
1076     OH_CryptoKeyPair_Destroy(keyCtx);
1077 }
1078 
1079 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest023, TestSize.Level0)
1080 {
1081     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("ECC_BrainPoolP384r1");
1082     ASSERT_NE(keyCtx, nullptr);
1083     Crypto_DataBlob pubKeyXData = {.data = nullptr, .len = 0};
1084     Crypto_DataBlob pubKeyYData = {.data = nullptr, .len = 0};
1085     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
1086     OH_Crypto_ErrCode ret = GetEccKeyParams(keyCtx, &pubKeyXData, &pubKeyYData, &privKeyData);
1087     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1088 
1089     OH_CryptoAsymKeySpec *ecCommonSpec = nullptr;
1090     ret = OH_CryptoAsymKeySpec_GenEcCommonParamsSpec("NID_brainpoolP384r1", &ecCommonSpec);
1091     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1092     OH_CryptoAsymKeySpec *keySpec = nullptr;
1093     ret = OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &keySpec);
1094     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1095     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, ecCommonSpec);
1096     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1097     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1098     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1099     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1100     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1101     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1102     EXPECT_NE(ret, CRYPTO_SUCCESS);
1103     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1104     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1105     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1106     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1107     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1108     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1109     EXPECT_NE(ret, CRYPTO_SUCCESS);
1110     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1111 
1112     OH_CryptoKeyPair *keyPair = nullptr;
1113     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1114     // 输入使用大端时会校验成功
1115     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1116     ASSERT_NE(keyPair, nullptr);
1117     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1118     EXPECT_EQ(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1119 
1120     OH_CryptoKeyPair_Destroy(keyPair);
1121     OH_CryptoAsymKeySpec_Destroy(keySpec);
1122     OH_CryptoAsymKeySpec_Destroy(ecCommonSpec);
1123     OH_CryptoKeyPair_Destroy(keyCtx);
1124 }
1125 
1126 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest024, TestSize.Level0)
1127 {
1128     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("ECC_BrainPoolP384r1");
1129     ASSERT_NE(keyCtx, nullptr);
1130     Crypto_DataBlob pubKeyXData = {.data = nullptr, .len = 0};
1131     Crypto_DataBlob pubKeyYData = {.data = nullptr, .len = 0};
1132     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
1133     OH_Crypto_ErrCode ret = GetEccKeyParams(keyCtx, &pubKeyXData, &pubKeyYData, &privKeyData);
1134     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1135 
1136     OH_CryptoAsymKeySpec *ecCommonSpec = nullptr;
1137     ret = OH_CryptoAsymKeySpec_GenEcCommonParamsSpec("NID_brainpoolP384r1", &ecCommonSpec);
1138     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1139     OH_CryptoAsymKeySpec *keySpec = nullptr;
1140     ret = OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &keySpec);
1141     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1142     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, ecCommonSpec);
1143     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1144     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1145     EXPECT_NE(ret, CRYPTO_SUCCESS);
1146     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1147     EXPECT_NE(ret, CRYPTO_SUCCESS);
1148     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1149     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1150     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1151     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_X_DATABLOB, &pubKeyXData);
1152     EXPECT_NE(ret, CRYPTO_SUCCESS);
1153     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_PK_Y_DATABLOB, &pubKeyYData);
1154     EXPECT_NE(ret, CRYPTO_SUCCESS);
1155     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_SK_DATABLOB, &privKeyData);
1156     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1157     FreeEccKeyParams(&pubKeyXData, &pubKeyYData, &privKeyData);
1158 
1159     OH_CryptoKeyPair *keyPair = nullptr;
1160     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1161     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1162     ASSERT_NE(keyPair, nullptr);
1163     EXPECT_EQ(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1164     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1165 
1166     OH_CryptoKeyPair_Destroy(keyPair);
1167     OH_CryptoAsymKeySpec_Destroy(keySpec);
1168     OH_CryptoAsymKeySpec_Destroy(ecCommonSpec);
1169     OH_CryptoKeyPair_Destroy(keyCtx);
1170 }
1171 
1172 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest025, TestSize.Level0)
1173 {
1174     OH_CryptoAsymKeySpec *ecCommonSpec = nullptr;
1175     OH_Crypto_ErrCode ret = OH_CryptoAsymKeySpec_GenEcCommonParamsSpec("NID_brainpoolP384r1", &ecCommonSpec);
1176     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1177     OH_CryptoAsymKeySpec *keySpec = nullptr;
1178     ret = OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec);
1179     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1180     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, ecCommonSpec);
1181     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1182 
1183     Crypto_DataBlob p = {0};
1184     Crypto_DataBlob a = {0};
1185     Crypto_DataBlob b = {0};
1186     Crypto_DataBlob gx = {0};
1187     Crypto_DataBlob gy = {0};
1188     Crypto_DataBlob n = {0};
1189     Crypto_DataBlob h = {0};
1190     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_FP_P_DATABLOB, &p);
1191     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1192     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_A_DATABLOB, &a);
1193     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1194     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_B_DATABLOB, &b);
1195     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1196     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_G_X_DATABLOB, &gx);
1197     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1198     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_G_Y_DATABLOB, &gy);
1199     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1200     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_N_DATABLOB, &n);
1201     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1202     ret = OH_CryptoAsymKeySpec_GetParam(keySpec, CRYPTO_ECC_H_INT, &h);
1203     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1204     FreeEccCommonParams(&p, &a, &b, &gx, &gy, &n, &h);
1205 
1206     OH_CryptoKeyPair *keyPair = nullptr;
1207     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1208     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1209     ASSERT_NE(keyPair, nullptr);
1210     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1211     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1212     OH_CryptoKeyPair_Destroy(keyPair);
1213     OH_CryptoAsymKeySpec_Destroy(keySpec);
1214     OH_CryptoAsymKeySpec_Destroy(ecCommonSpec);
1215 }
1216 
1217 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest026, TestSize.Level0)
1218 {
1219     OH_CryptoAsymKeySpec *ecCommonSpec = nullptr;
1220     EXPECT_EQ(OH_CryptoAsymKeySpec_GenEcCommonParamsSpec("NID_brainpoolP384r1", &ecCommonSpec), CRYPTO_SUCCESS);
1221 
1222     Crypto_DataBlob p = {0};
1223     Crypto_DataBlob a = {0};
1224     Crypto_DataBlob b = {0};
1225     Crypto_DataBlob gx = {0};
1226     Crypto_DataBlob gy = {0};
1227     Crypto_DataBlob n = {0};
1228     Crypto_DataBlob h = {0};
1229     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_FP_P_DATABLOB, &p), CRYPTO_SUCCESS);
1230     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_A_DATABLOB, &a), CRYPTO_SUCCESS);
1231     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_B_DATABLOB, &b), CRYPTO_SUCCESS);
1232     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_G_X_DATABLOB, &gx), CRYPTO_SUCCESS);
1233     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_G_Y_DATABLOB, &gy), CRYPTO_SUCCESS);
1234     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_N_DATABLOB, &n), CRYPTO_SUCCESS);
1235     EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(ecCommonSpec, CRYPTO_ECC_H_INT, &h), CRYPTO_SUCCESS);
1236 
1237     OH_CryptoAsymKeySpec *keySpec = nullptr;
1238     EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &keySpec), CRYPTO_SUCCESS);
1239     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_FP_P_DATABLOB, &p), CRYPTO_SUCCESS);
1240     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_A_DATABLOB, &a), CRYPTO_SUCCESS);
1241     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_B_DATABLOB, &b), CRYPTO_SUCCESS);
1242     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_G_X_DATABLOB, &gx), CRYPTO_SUCCESS);
1243     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_G_Y_DATABLOB, &gy), CRYPTO_SUCCESS);
1244     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_N_DATABLOB, &n), CRYPTO_SUCCESS);
1245     EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_ECC_H_INT, &h), CRYPTO_SUCCESS);
1246 
1247     OH_CryptoKeyPair *keyPair = nullptr;
1248     EXPECT_EQ(GenerateKeyPairWithSpec(keySpec, &keyPair), CRYPTO_SUCCESS);
1249     ASSERT_NE(keyPair, nullptr);
1250     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1251     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1252     FreeEccCommonParams(&p, &a, &b, &gx, &gy, &n, &h);
1253     OH_CryptoKeyPair_Destroy(keyPair);
1254     OH_CryptoAsymKeySpec_Destroy(keySpec);
1255     OH_CryptoAsymKeySpec_Destroy(ecCommonSpec);
1256 }
1257 
1258 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest027, TestSize.Level0)
1259 {
1260     uint8_t prime256v1PointBlobData[] = {
1261         4,   153, 228, 156, 119, 184, 185, 120, 237, 233, 181, 77,  70,  183, 30,  68, 2,   70,  37,  251, 5,   22,
1262         199, 84,  87,  222, 65,  103, 8,   26,  255, 137, 206, 80,  159, 163, 46,  22, 104, 156, 169, 14,  149, 199,
1263         35,  201, 3,   160, 81,  251, 235, 236, 75,  137, 196, 253, 200, 116, 167, 59, 153, 241, 99,  90,  90};
1264     OH_CryptoEcPoint *point = nullptr;
1265     Crypto_DataBlob prime256v1PointBlob = {prime256v1PointBlobData, sizeof(prime256v1PointBlobData)};
1266     OH_Crypto_ErrCode ret = OH_CryptoEcPoint_Create("NID_X9_62_prime256v1", &prime256v1PointBlob, &point);
1267     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1268     ASSERT_NE(point, nullptr);
1269 
1270     Crypto_DataBlob ecPubKeyX = {0};
1271     Crypto_DataBlob ecPubKeyY = {0};
1272     ret = OH_CryptoEcPoint_GetCoordinate(point, &ecPubKeyX, &ecPubKeyY);
1273     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1274     ASSERT_NE(ecPubKeyX.data, nullptr);
1275     ASSERT_NE(ecPubKeyY.data, nullptr);
1276     ASSERT_NE(ecPubKeyX.len, 0);
1277     ASSERT_NE(ecPubKeyY.len, 0);
1278 
1279     OH_CryptoEcPoint *point2 = nullptr;
1280     ret = OH_CryptoEcPoint_Create("NID_X9_62_prime256v1", nullptr, &point2);
1281     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1282     ASSERT_NE(point2, nullptr);
1283 
1284     ret = OH_CryptoEcPoint_SetCoordinate(point2, &ecPubKeyX, &ecPubKeyY);
1285     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1286 
1287     Crypto_DataBlob returnPointBlobData = {0};
1288     ret = OH_CryptoEcPoint_Encode(point2, "UNCOMPRESSED", &returnPointBlobData);
1289     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1290     ASSERT_NE(returnPointBlobData.data, nullptr);
1291     ASSERT_NE(returnPointBlobData.len, 0);
1292     EXPECT_EQ(returnPointBlobData.len, prime256v1PointBlob.len);
1293     EXPECT_EQ(memcmp(returnPointBlobData.data, prime256v1PointBlob.data, returnPointBlobData.len), 0);
1294 
1295     OH_Crypto_FreeDataBlob(&ecPubKeyX);
1296     OH_Crypto_FreeDataBlob(&ecPubKeyY);
1297     OH_Crypto_FreeDataBlob(&returnPointBlobData);
1298     OH_CryptoEcPoint_Destroy(point);
1299     OH_CryptoEcPoint_Destroy(point2);
1300 }
1301 
1302 HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest028, TestSize.Level0)
1303 {
1304     OH_CryptoKeyPair *keyCtx = GenerateKeyPair("DSA2048");
1305     ASSERT_NE(keyCtx, nullptr);
1306     Crypto_DataBlob pubKeyData = {.data = nullptr, .len = 0};
1307     Crypto_DataBlob privKeyData = {.data = nullptr, .len = 0};
1308     Crypto_DataBlob pData = {.data = nullptr, .len = 0};
1309     Crypto_DataBlob qData = {.data = nullptr, .len = 0};
1310     Crypto_DataBlob gData = {.data = nullptr, .len = 0};
1311     OH_Crypto_ErrCode ret = GetDsaKeyParams(keyCtx, &pubKeyData, &privKeyData, &pData, &qData, &gData);
1312     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1313 
1314     OH_CryptoAsymKeySpec *dsaCommonSpec = nullptr;
1315     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &dsaCommonSpec);
1316     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1317     ret = OH_CryptoAsymKeySpec_SetParam(dsaCommonSpec, CRYPTO_DSA_P_DATABLOB, &pData);
1318     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1319     ret = OH_CryptoAsymKeySpec_SetParam(dsaCommonSpec, CRYPTO_DSA_Q_DATABLOB, &qData);
1320     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1321     ret = OH_CryptoAsymKeySpec_SetParam(dsaCommonSpec, CRYPTO_DSA_G_DATABLOB, &gData);
1322     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1323 
1324     OH_CryptoAsymKeySpec *keySpec = nullptr;
1325     ret = OH_CryptoAsymKeySpec_Create("DSA", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &keySpec);
1326     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1327     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_PK_DATABLOB, &pubKeyData);
1328     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1329     ret = OH_CryptoAsymKeySpec_SetParam(keySpec, CRYPTO_DSA_SK_DATABLOB, &privKeyData);
1330     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1331     FreeDsaKeyParams(&pubKeyData, &privKeyData, &pData, &qData, &gData);
1332     ret = OH_CryptoAsymKeySpec_SetCommonParamsSpec(keySpec, dsaCommonSpec);
1333     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1334 
1335     OH_CryptoKeyPair *keyPair = nullptr;
1336     ret = GenerateKeyPairWithSpec(keySpec, &keyPair);
1337     EXPECT_EQ(ret, CRYPTO_SUCCESS);
1338     ASSERT_NE(keyPair, nullptr);
1339     ASSERT_NE(OH_CryptoKeyPair_GetPubKey(keyPair), nullptr);
1340     ASSERT_NE(OH_CryptoKeyPair_GetPrivKey(keyPair), nullptr);
1341 
1342     OH_CryptoKeyPair_Destroy(keyPair);
1343     OH_CryptoAsymKeySpec_Destroy(dsaCommonSpec);
1344     OH_CryptoAsymKeySpec_Destroy(keySpec);
1345     OH_CryptoKeyPair_Destroy(keyCtx);
1346 }
1347 }