1 /*
2  * Copyright (C) 2023-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 "dsa_asy_key_generator_openssl.h"
17 
18 #include <openssl/dsa.h>
19 #include <openssl/evp.h>
20 #include <string.h>
21 
22 #include "detailed_dsa_key_params.h"
23 #include "log.h"
24 #include "memory.h"
25 #include "openssl_adapter.h"
26 #include "openssl_class.h"
27 #include "openssl_common.h"
28 #include "utils.h"
29 
30 #define OPENSSL_DSA_GENERATOR_CLASS "OPENSSL.DSA.KEYGENERATOR"
31 #define OPENSSL_DSA_PUBKEY_FORMAT "X.509"
32 #define OPENSSL_DSA_PRIKEY_FORMAT "PKCS#8"
33 #define ALGORITHM_NAME_DSA "DSA"
34 
35 typedef struct {
36     HcfAsyKeyGeneratorSpi base;
37 
38     int32_t bits;
39 } HcfAsyKeyGeneratorSpiDsaOpensslImpl;
40 
FreeCtx(EVP_PKEY_CTX * paramsCtx,EVP_PKEY * paramsPkey,EVP_PKEY_CTX * pkeyCtx)41 static void FreeCtx(EVP_PKEY_CTX *paramsCtx, EVP_PKEY *paramsPkey, EVP_PKEY_CTX *pkeyCtx)
42 {
43     if (paramsCtx != NULL) {
44         OpensslEvpPkeyCtxFree(paramsCtx);
45     }
46     if (paramsPkey != NULL) {
47         OpensslEvpPkeyFree(paramsPkey);
48     }
49     if (pkeyCtx != NULL) {
50         OpensslEvpPkeyCtxFree(pkeyCtx);
51     }
52 }
53 
FreeCommSpecBn(BIGNUM * p,BIGNUM * q,BIGNUM * g)54 static void FreeCommSpecBn(BIGNUM *p, BIGNUM *q, BIGNUM *g)
55 {
56     if (p != NULL) {
57         OpensslBnFree(p);
58     }
59     if (q != NULL) {
60         OpensslBnFree(q);
61     }
62     if (g != NULL) {
63         OpensslBnFree(g);
64     }
65 }
66 
GetDsaKeyGeneratorSpiClass(void)67 static const char *GetDsaKeyGeneratorSpiClass(void)
68 {
69     return OPENSSL_DSA_GENERATOR_CLASS;
70 }
71 
GetDsaKeyPairClass(void)72 static const char *GetDsaKeyPairClass(void)
73 {
74     return OPENSSL_DSA_KEYPAIR_CLASS;
75 }
76 
GetDsaPubKeyClass(void)77 static const char *GetDsaPubKeyClass(void)
78 {
79     return OPENSSL_DSA_PUBKEY_CLASS;
80 }
81 
GetDsaPriKeyClass(void)82 static const char *GetDsaPriKeyClass(void)
83 {
84     return OPENSSL_DSA_PRIKEY_CLASS;
85 }
86 
DestroyDsaKeyGeneratorSpiImpl(HcfObjectBase * self)87 static void DestroyDsaKeyGeneratorSpiImpl(HcfObjectBase *self)
88 {
89     if (self == NULL) {
90         return;
91     }
92     if (!HcfIsClassMatch(self, GetDsaKeyGeneratorSpiClass())) {
93         return;
94     }
95     HcfFree(self);
96 }
97 
DestroyDsaPubKey(HcfObjectBase * self)98 static void DestroyDsaPubKey(HcfObjectBase *self)
99 {
100     if (self == NULL) {
101         return;
102     }
103     if (!HcfIsClassMatch(self, GetDsaPubKeyClass())) {
104         return;
105     }
106     HcfOpensslDsaPubKey *impl = (HcfOpensslDsaPubKey *)self;
107     OpensslDsaFree(impl->pk);
108     impl->pk = NULL;
109     HcfFree(impl);
110 }
111 
DestroyDsaPriKey(HcfObjectBase * self)112 static void DestroyDsaPriKey(HcfObjectBase *self)
113 {
114     if (self == NULL) {
115         return;
116     }
117     if (!HcfIsClassMatch(self, GetDsaPriKeyClass())) {
118         return;
119     }
120     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
121     OpensslDsaFree(impl->sk);
122     impl->sk = NULL;
123     HcfFree(impl);
124 }
125 
DestroyDsaKeyPair(HcfObjectBase * self)126 static void DestroyDsaKeyPair(HcfObjectBase *self)
127 {
128     if (self == NULL) {
129         return;
130     }
131     if (!HcfIsClassMatch(self, GetDsaKeyPairClass())) {
132         return;
133     }
134     HcfOpensslDsaKeyPair *impl = (HcfOpensslDsaKeyPair *)self;
135     DestroyDsaPubKey((HcfObjectBase *)impl->base.pubKey);
136     impl->base.pubKey = NULL;
137     DestroyDsaPriKey((HcfObjectBase *)impl->base.priKey);
138     impl->base.priKey = NULL;
139     HcfFree(self);
140 }
141 
GetDsaPubKeyAlgorithm(HcfKey * self)142 static const char *GetDsaPubKeyAlgorithm(HcfKey *self)
143 {
144     if (self == NULL) {
145         LOGE("Invalid input parameter.");
146         return NULL;
147     }
148     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
149         return NULL;
150     }
151     return ALGORITHM_NAME_DSA;
152 }
153 
GetDsaPriKeyAlgorithm(HcfKey * self)154 static const char *GetDsaPriKeyAlgorithm(HcfKey *self)
155 {
156     if (self == NULL) {
157         LOGE("Invalid input parameter.");
158         return NULL;
159     }
160     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
161         return NULL;
162     }
163     return ALGORITHM_NAME_DSA;
164 }
165 
GetDsaPubKeyEncoded(HcfKey * self,HcfBlob * returnBlob)166 static HcfResult GetDsaPubKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
167 {
168     if ((self == NULL) || (returnBlob == NULL)) {
169         LOGE("Invalid input parameter.");
170         return HCF_INVALID_PARAMS;
171     }
172     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
173         return HCF_INVALID_PARAMS;
174     }
175     HcfOpensslDsaPubKey *impl = (HcfOpensslDsaPubKey *)self;
176     unsigned char *returnData = NULL;
177     int len = OpensslI2dDsaPubkey(impl->pk, &returnData);
178     if (len <= 0) {
179         LOGD("[error] Call i2d_DSA_PUBKEY failed");
180         HcfPrintOpensslError();
181         return HCF_ERR_CRYPTO_OPERATION;
182     }
183     returnBlob->data = returnData;
184     returnBlob->len = len;
185     return HCF_SUCCESS;
186 }
187 
GetDsaPubKeyEncodedPem(HcfKey * self,const char * format,char ** returnString)188 static HcfResult GetDsaPubKeyEncodedPem(HcfKey *self, const char *format, char **returnString)
189 {
190     (void)self;
191     (void)format;
192     (void)returnString;
193     return HCF_INVALID_PARAMS;
194 }
195 
GetDsaPriKeyEncoded(HcfKey * self,HcfBlob * returnBlob)196 static HcfResult GetDsaPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
197 {
198     if ((self == NULL) || (returnBlob == NULL)) {
199         LOGE("Invalid input parameter.");
200         return HCF_INVALID_PARAMS;
201     }
202     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
203         return HCF_INVALID_PARAMS;
204     }
205     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
206     unsigned char *returnData = NULL;
207     int len = OpensslI2dDsaPrivateKey(impl->sk, &returnData);
208     if (len <= 0) {
209         LOGD("[error] Call i2d_DSAPrivateKey failed.");
210         HcfPrintOpensslError();
211         return HCF_ERR_CRYPTO_OPERATION;
212     }
213     returnBlob->data = returnData;
214     returnBlob->len = len;
215     return HCF_SUCCESS;
216 }
217 
GetDsaPriKeyEncodedPem(HcfKey * self,const char * format,char ** returnString)218 static HcfResult GetDsaPriKeyEncodedPem(HcfKey *self, const char *format, char **returnString)
219 {
220     (void)self;
221     (void)format;
222     (void)returnString;
223     return HCF_INVALID_PARAMS;
224 }
225 
GetDsaPubKeyFormat(HcfKey * self)226 static const char *GetDsaPubKeyFormat(HcfKey *self)
227 {
228     if (self == NULL) {
229         LOGE("Invalid input parameter.");
230         return NULL;
231     }
232     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
233         return NULL;
234     }
235     return OPENSSL_DSA_PUBKEY_FORMAT;
236 }
237 
GetDsaPriKeyFormat(HcfKey * self)238 static const char *GetDsaPriKeyFormat(HcfKey *self)
239 {
240     if (self == NULL) {
241         LOGE("Invalid input parameter.");
242         return NULL;
243     }
244     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
245         return NULL;
246     }
247     return OPENSSL_DSA_PRIKEY_FORMAT;
248 }
249 
GetBigIntegerSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)250 static HcfResult GetBigIntegerSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item,
251     HcfBigInteger *returnBigInteger)
252 {
253     if (self ==  NULL || returnBigInteger == NULL) {
254         LOGE("Invalid input parameter.");
255         return HCF_INVALID_PARAMS;
256     }
257     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
258         LOGE("Invalid class of self.");
259         return HCF_INVALID_PARAMS;
260     }
261     HcfResult ret = HCF_SUCCESS;
262     HcfOpensslDsaPubKey *impl = (HcfOpensslDsaPubKey *)self;
263     DSA *dsaPk = impl->pk;
264     if (dsaPk == NULL) {
265         return HCF_INVALID_PARAMS;
266     }
267     switch (item) {
268         case DSA_P_BN:
269             ret = BigNumToBigInteger(OpensslDsaGet0P(dsaPk), returnBigInteger);
270             break;
271         case DSA_Q_BN:
272             ret = BigNumToBigInteger(OpensslDsaGet0Q(dsaPk), returnBigInteger);
273             break;
274         case DSA_G_BN:
275             ret = BigNumToBigInteger(OpensslDsaGet0G(dsaPk), returnBigInteger);
276             break;
277         case DSA_PK_BN:
278             ret = BigNumToBigInteger(OpensslDsaGet0PubKey(dsaPk), returnBigInteger);
279             break;
280         default:
281             LOGE("Input item is invalid");
282             ret = HCF_INVALID_PARAMS;
283             break;
284     }
285     return ret;
286 }
287 
GetBigIntegerSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)288 static HcfResult GetBigIntegerSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item,
289     HcfBigInteger *returnBigInteger)
290 {
291     if (self ==  NULL || returnBigInteger == NULL) {
292         LOGE("Invalid input parameter.");
293         return HCF_INVALID_PARAMS;
294     }
295     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
296         LOGE("Invalid class of self.");
297         return HCF_INVALID_PARAMS;
298     }
299     HcfResult ret = HCF_SUCCESS;
300     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
301     DSA *dsaSk = impl->sk;
302     if (dsaSk == NULL) {
303         return HCF_INVALID_PARAMS;
304     }
305     switch (item) {
306         case DSA_P_BN:
307             ret = BigNumToBigInteger(OpensslDsaGet0P(dsaSk), returnBigInteger);
308             break;
309         case DSA_Q_BN:
310             ret = BigNumToBigInteger(OpensslDsaGet0Q(dsaSk), returnBigInteger);
311             break;
312         case DSA_G_BN:
313             ret = BigNumToBigInteger(OpensslDsaGet0G(dsaSk), returnBigInteger);
314             break;
315         case DSA_SK_BN:
316             ret = BigNumToBigInteger(OpensslDsaGet0PrivKey(dsaSk), returnBigInteger);
317             break;
318         default:
319             LOGE("Input item is invalid");
320             ret = HCF_INVALID_PARAMS;
321             break;
322     }
323     return ret;
324 }
325 
GetIntSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,int * returnInt)326 static HcfResult GetIntSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item, int *returnInt)
327 {
328     (void)self;
329     (void)returnInt;
330     return HCF_NOT_SUPPORT;
331 }
332 
GetIntSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,int * returnInt)333 static HcfResult GetIntSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item, int *returnInt)
334 {
335     (void)self;
336     (void)returnInt;
337     return HCF_NOT_SUPPORT;
338 }
339 
GetStrSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,char ** returnString)340 static HcfResult GetStrSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item, char **returnString)
341 {
342     (void)self;
343     (void)returnString;
344     return HCF_NOT_SUPPORT;
345 }
346 
GetStrSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,char ** returnString)347 static HcfResult GetStrSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item, char **returnString)
348 {
349     (void)self;
350     (void)returnString;
351     return HCF_NOT_SUPPORT;
352 }
353 
ClearDsaPriKeyMem(HcfPriKey * self)354 static void ClearDsaPriKeyMem(HcfPriKey *self)
355 {
356     if (self == NULL) {
357         return;
358     }
359     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
360         return;
361     }
362     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
363     OpensslDsaFree(impl->sk);
364     impl->sk = NULL;
365 }
366 
GetDsaPriKeyEncodedDer(const HcfPriKey * self,const char * format,HcfBlob * returnBlob)367 static HcfResult GetDsaPriKeyEncodedDer(const HcfPriKey *self, const char *format, HcfBlob *returnBlob)
368 {
369     (void)self;
370     (void)format;
371     (void)returnBlob;
372     return HCF_INVALID_PARAMS;
373 }
374 
GenerateDsaEvpKey(int32_t keyLen,EVP_PKEY ** ppkey)375 static HcfResult GenerateDsaEvpKey(int32_t keyLen, EVP_PKEY **ppkey)
376 {
377     EVP_PKEY_CTX *paramsCtx = NULL;
378     EVP_PKEY *paramsPkey = NULL;
379     EVP_PKEY_CTX *pkeyCtx = NULL;
380     HcfResult ret = HCF_SUCCESS;
381     do {
382         paramsCtx = OpensslEvpPkeyCtxNewId(EVP_PKEY_DSA, NULL);
383         if (paramsCtx == NULL) {
384             LOGE("Create params ctx failed.");
385             ret = HCF_ERR_MALLOC;
386             break;
387         }
388         if (OpensslEvpPkeyParamGenInit(paramsCtx) != HCF_OPENSSL_SUCCESS) {
389             LOGD("[error] Params ctx generate init failed.");
390             ret = HCF_ERR_CRYPTO_OPERATION;
391             break;
392         }
393         if (OpensslEvpPkeyCtxSetDsaParamgenBits(paramsCtx, keyLen) <= 0) {
394             LOGD("[error] Set length of bits to params ctx failed.");
395             ret = HCF_ERR_CRYPTO_OPERATION;
396             break;
397         }
398         if (OpensslEvpPkeyParamGen(paramsCtx, &paramsPkey) != HCF_OPENSSL_SUCCESS) {
399             LOGD("[error] Generate params pkey failed.");
400             ret = HCF_ERR_CRYPTO_OPERATION;
401             break;
402         }
403         pkeyCtx = OpensslEvpPkeyCtxNew(paramsPkey, NULL);
404         if (pkeyCtx == NULL) {
405             LOGD("[error] Create pkey ctx failed.");
406             ret = HCF_ERR_CRYPTO_OPERATION;
407             break;
408         }
409         if (OpensslEvpPkeyKeyGenInit(pkeyCtx) != HCF_OPENSSL_SUCCESS) {
410             LOGD("[error] Key ctx generate init failed.");
411             ret = HCF_ERR_CRYPTO_OPERATION;
412             break;
413         }
414         if (OpensslEvpPkeyKeyGen(pkeyCtx, ppkey) != HCF_OPENSSL_SUCCESS) {
415             LOGD("[error] Generate pkey failed.");
416             ret = HCF_ERR_CRYPTO_OPERATION;
417             break;
418         }
419     } while (0);
420     FreeCtx(paramsCtx, paramsPkey, pkeyCtx);
421     return ret;
422 }
423 
GetDsaPubKeyEncodedDer(const HcfPubKey * self,const char * format,HcfBlob * returnBlob)424 static HcfResult GetDsaPubKeyEncodedDer(const HcfPubKey *self, const char *format, HcfBlob *returnBlob)
425 {
426     (void)self;
427     (void)format;
428     (void)returnBlob;
429     return HCF_INVALID_PARAMS;
430 }
431 
FillOpensslDsaPubKeyFunc(HcfOpensslDsaPubKey * pk)432 static void FillOpensslDsaPubKeyFunc(HcfOpensslDsaPubKey *pk)
433 {
434     pk->base.base.base.destroy = DestroyDsaPubKey;
435     pk->base.base.base.getClass = GetDsaPubKeyClass;
436     pk->base.base.getAlgorithm = GetDsaPubKeyAlgorithm;
437     pk->base.base.getEncoded = GetDsaPubKeyEncoded;
438     pk->base.base.getEncodedPem = GetDsaPubKeyEncodedPem;
439     pk->base.base.getFormat = GetDsaPubKeyFormat;
440     pk->base.getAsyKeySpecBigInteger = GetBigIntegerSpecFromDsaPubKey;
441     pk->base.getAsyKeySpecInt = GetIntSpecFromDsaPubKey;
442     pk->base.getAsyKeySpecString = GetStrSpecFromDsaPubKey;
443     pk->base.getEncodedDer = GetDsaPubKeyEncodedDer;
444 }
445 
FillOpensslDsaPriKeyFunc(HcfOpensslDsaPriKey * sk)446 static void FillOpensslDsaPriKeyFunc(HcfOpensslDsaPriKey *sk)
447 {
448     sk->base.base.base.destroy = DestroyDsaPriKey;
449     sk->base.base.base.getClass = GetDsaPriKeyClass;
450     sk->base.base.getAlgorithm = GetDsaPriKeyAlgorithm;
451     sk->base.base.getEncoded = GetDsaPriKeyEncoded;
452     sk->base.base.getEncodedPem = GetDsaPriKeyEncodedPem;
453     sk->base.base.getFormat = GetDsaPriKeyFormat;
454     sk->base.getAsyKeySpecBigInteger = GetBigIntegerSpecFromDsaPriKey;
455     sk->base.getAsyKeySpecInt = GetIntSpecFromDsaPriKey;
456     sk->base.getAsyKeySpecString = GetStrSpecFromDsaPriKey;
457     sk->base.clearMem = ClearDsaPriKeyMem;
458     sk->base.getEncodedDer = GetDsaPriKeyEncodedDer;
459 }
460 
CreateDsaPubKey(DSA * pk,HcfOpensslDsaPubKey ** returnPubKey)461 static HcfResult CreateDsaPubKey(DSA *pk, HcfOpensslDsaPubKey **returnPubKey)
462 {
463     HcfOpensslDsaPubKey *dsaPubKey = (HcfOpensslDsaPubKey *)HcfMalloc(sizeof(HcfOpensslDsaPubKey), 0);
464     if (dsaPubKey == NULL) {
465         LOGE("Failed to allocate DSA public key memory.");
466         return HCF_ERR_MALLOC;
467     }
468     FillOpensslDsaPubKeyFunc(dsaPubKey);
469     dsaPubKey->pk = pk;
470 
471     *returnPubKey = dsaPubKey;
472     return HCF_SUCCESS;
473 }
474 
CreateDsaPriKey(DSA * sk,HcfOpensslDsaPriKey ** returnPriKey)475 static HcfResult CreateDsaPriKey(DSA *sk, HcfOpensslDsaPriKey **returnPriKey)
476 {
477     HcfOpensslDsaPriKey *dsaPriKey = (HcfOpensslDsaPriKey *)HcfMalloc(sizeof(HcfOpensslDsaPriKey), 0);
478     if (dsaPriKey == NULL) {
479         LOGE("Failed to allocate DSA private key memory.");
480         return HCF_ERR_MALLOC;
481     }
482     FillOpensslDsaPriKeyFunc(dsaPriKey);
483     dsaPriKey->sk = sk;
484 
485     *returnPriKey = dsaPriKey;
486     return HCF_SUCCESS;
487 }
488 
CreateDsaKeyPair(const HcfOpensslDsaPubKey * pubKey,const HcfOpensslDsaPriKey * priKey,HcfKeyPair ** returnKeyPair)489 static HcfResult CreateDsaKeyPair(const HcfOpensslDsaPubKey *pubKey, const HcfOpensslDsaPriKey *priKey,
490     HcfKeyPair **returnKeyPair)
491 {
492     HcfOpensslDsaKeyPair *keyPair = (HcfOpensslDsaKeyPair *)HcfMalloc(sizeof(HcfOpensslDsaKeyPair), 0);
493     if (keyPair == NULL) {
494         LOGE("Failed to allocate keyPair memory.");
495         return HCF_ERR_MALLOC;
496     }
497     keyPair->base.base.getClass = GetDsaKeyPairClass;
498     keyPair->base.base.destroy = DestroyDsaKeyPair;
499     keyPair->base.pubKey = (HcfPubKey *)pubKey;
500     keyPair->base.priKey = (HcfPriKey *)priKey;
501 
502     *returnKeyPair = (HcfKeyPair *)keyPair;
503     return HCF_SUCCESS;
504 }
505 
GeneratePubKeyByPkey(EVP_PKEY * pkey,HcfOpensslDsaPubKey ** returnPubKey)506 static HcfResult GeneratePubKeyByPkey(EVP_PKEY *pkey, HcfOpensslDsaPubKey **returnPubKey)
507 {
508     DSA *pk = OpensslEvpPkeyGet1Dsa(pkey);
509     if (pk == NULL) {
510         LOGD("[error] Get das public key from pkey failed");
511         HcfPrintOpensslError();
512         return HCF_ERR_CRYPTO_OPERATION;
513     }
514     HcfResult ret = CreateDsaPubKey(pk, returnPubKey);
515     if (ret != HCF_SUCCESS) {
516         LOGD("[error] Create DSA public key failed");
517         OpensslDsaFree(pk);
518     }
519     return ret;
520 }
521 
GeneratePriKeyByPkey(EVP_PKEY * pkey,HcfOpensslDsaPriKey ** returnPriKey)522 static HcfResult GeneratePriKeyByPkey(EVP_PKEY *pkey, HcfOpensslDsaPriKey **returnPriKey)
523 {
524     DSA *sk = OpensslEvpPkeyGet1Dsa(pkey);
525     if (sk == NULL) {
526         LOGD("[error] Get DSA private key from pkey failed");
527         HcfPrintOpensslError();
528         return HCF_ERR_CRYPTO_OPERATION;
529     }
530     HcfResult ret = CreateDsaPriKey(sk, returnPriKey);
531     if (ret != HCF_SUCCESS) {
532         LOGD("[error] Create DSA private key failed");
533         OpensslDsaFree(sk);
534     }
535     return ret;
536 }
537 
GenerateDsaPubAndPriKey(int32_t keyLen,HcfOpensslDsaPubKey ** returnPubKey,HcfOpensslDsaPriKey ** returnPriKey)538 static HcfResult GenerateDsaPubAndPriKey(int32_t keyLen, HcfOpensslDsaPubKey **returnPubKey,
539     HcfOpensslDsaPriKey **returnPriKey)
540 {
541     EVP_PKEY *pkey = NULL;
542     HcfResult ret = GenerateDsaEvpKey(keyLen, &pkey);
543     if (ret != HCF_SUCCESS) {
544         LOGD("[error] Generate DSA EVP_PKEY failed.");
545         return ret;
546     }
547 
548     ret = GeneratePubKeyByPkey(pkey, returnPubKey);
549     if (ret != HCF_SUCCESS) {
550         OpensslEvpPkeyFree(pkey);
551         return ret;
552     }
553 
554     ret = GeneratePriKeyByPkey(pkey, returnPriKey);
555     if (ret != HCF_SUCCESS) {
556         HcfObjDestroy(*returnPubKey);
557         *returnPubKey = NULL;
558         OpensslEvpPkeyFree(pkey);
559         return HCF_ERR_CRYPTO_OPERATION;
560     }
561 
562     OpensslEvpPkeyFree(pkey);
563     return ret;
564 }
565 
ConvertCommSpec2Bn(const HcfDsaCommParamsSpec * paramsSpec,BIGNUM ** p,BIGNUM ** q,BIGNUM ** g)566 static HcfResult ConvertCommSpec2Bn(const HcfDsaCommParamsSpec *paramsSpec, BIGNUM **p, BIGNUM **q, BIGNUM **g)
567 {
568     if (BigIntegerToBigNum(&(paramsSpec->p), p) != HCF_SUCCESS) {
569         LOGD("[error] Get openssl BN p failed");
570         return HCF_ERR_CRYPTO_OPERATION;
571     }
572     if (BigIntegerToBigNum(&(paramsSpec->q), q) != HCF_SUCCESS)  {
573         LOGD("[error] Get openssl BN q failed");
574         OpensslBnFree(*p);
575         *p = NULL;
576         return HCF_ERR_CRYPTO_OPERATION;
577     }
578     if (BigIntegerToBigNum(&(paramsSpec->g), g) != HCF_SUCCESS) {
579         LOGD("[error] Get openssl BN g failed");
580         OpensslBnFree(*p);
581         *p = NULL;
582         OpensslBnFree(*q);
583         *q = NULL;
584         return HCF_ERR_CRYPTO_OPERATION;
585     }
586     return HCF_SUCCESS;
587 }
588 
CreateOpensslDsaKey(const HcfDsaCommParamsSpec * paramsSpec,BIGNUM * pk,BIGNUM * sk,DSA ** returnDsa)589 static HcfResult CreateOpensslDsaKey(const HcfDsaCommParamsSpec *paramsSpec, BIGNUM *pk, BIGNUM *sk, DSA **returnDsa)
590 {
591     BIGNUM *p = NULL;
592     BIGNUM *q = NULL;
593     BIGNUM *g = NULL;
594     if (ConvertCommSpec2Bn(paramsSpec, &p, &q, &g)!= HCF_SUCCESS) {
595         return HCF_ERR_CRYPTO_OPERATION;
596     }
597     DSA *dsa = OpensslDsaNew();
598     if (dsa == NULL) {
599         FreeCommSpecBn(p, q, g);
600         LOGD("[error] Openssl DSA new failed");
601         HcfPrintOpensslError();
602         return HCF_ERR_CRYPTO_OPERATION;
603     }
604     if (OpensslDsaSet0Pqg(dsa, p, q, g) != HCF_OPENSSL_SUCCESS) {
605         LOGD("[error] Openssl DSA set pqg failed");
606         FreeCommSpecBn(p, q, g);
607         HcfPrintOpensslError();
608         OpensslDsaFree(dsa);
609         return HCF_ERR_CRYPTO_OPERATION;
610     }
611     if ((pk == NULL) && (sk == NULL)) {
612         *returnDsa = dsa;
613         return HCF_SUCCESS;
614     }
615     if (OpensslDsaSet0Key(dsa, pk, sk) != HCF_OPENSSL_SUCCESS) {
616         LOGD("[error] Openssl DSA set pqg failed");
617         HcfPrintOpensslError();
618         OpensslDsaFree(dsa);
619         return HCF_ERR_CRYPTO_OPERATION;
620     }
621     *returnDsa = dsa;
622     return HCF_SUCCESS;
623 }
624 
GenerateOpensslDsaKeyByCommSpec(const HcfDsaCommParamsSpec * paramsSpec,DSA ** returnDsa)625 static HcfResult GenerateOpensslDsaKeyByCommSpec(const HcfDsaCommParamsSpec *paramsSpec, DSA **returnDsa)
626 {
627     if (CreateOpensslDsaKey(paramsSpec, NULL, NULL, returnDsa) != HCF_SUCCESS) {
628         return HCF_ERR_CRYPTO_OPERATION;
629     }
630 
631     if (OpensslDsaGenerateKey(*returnDsa) != HCF_OPENSSL_SUCCESS) {
632         LOGD("[error] Openssl DSA generate key failed");
633         HcfPrintOpensslError();
634         OpensslDsaFree(*returnDsa);
635         *returnDsa = NULL;
636         return HCF_ERR_CRYPTO_OPERATION;
637     }
638     return HCF_SUCCESS;
639 }
640 
GenerateOpensslDsaKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec * paramsSpec,DSA ** returnDsa)641 static HcfResult GenerateOpensslDsaKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec *paramsSpec, DSA **returnDsa)
642 {
643     BIGNUM *pubKey = NULL;
644     if (BigIntegerToBigNum(&(paramsSpec->pk), &pubKey) != HCF_SUCCESS) {
645         LOGD("[error] Get openssl BN pk failed");
646         return HCF_ERR_CRYPTO_OPERATION;
647     }
648 
649     if (CreateOpensslDsaKey(&(paramsSpec->base), pubKey, NULL, returnDsa) != HCF_SUCCESS) {
650         OpensslBnFree(pubKey);
651         return HCF_ERR_CRYPTO_OPERATION;
652     }
653     return HCF_SUCCESS;
654 }
655 
GenerateOpensslDsaKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,DSA ** returnDsa)656 static HcfResult GenerateOpensslDsaKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec, DSA **returnDsa)
657 {
658     BIGNUM *pubKey = NULL;
659     BIGNUM *priKey = NULL;
660     if (BigIntegerToBigNum(&(paramsSpec->pk), &pubKey) != HCF_SUCCESS) {
661         LOGD("[error] Get openssl BN pk failed");
662         return HCF_ERR_CRYPTO_OPERATION;
663     }
664     if (BigIntegerToBigNum(&(paramsSpec->sk), &priKey) != HCF_SUCCESS) {
665         LOGD("[error] Get openssl BN sk failed");
666         OpensslBnFree(pubKey);
667         return HCF_ERR_CRYPTO_OPERATION;
668     }
669     if (CreateOpensslDsaKey(&(paramsSpec->base), pubKey, priKey, returnDsa) != HCF_SUCCESS) {
670         OpensslBnFree(pubKey);
671         OpensslBnFree(priKey);
672         return HCF_ERR_CRYPTO_OPERATION;
673     }
674     return HCF_SUCCESS;
675 }
676 
CreateDsaKeyPairByCommSpec(const HcfDsaCommParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)677 static HcfResult CreateDsaKeyPairByCommSpec(const HcfDsaCommParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
678 {
679     DSA *dsa = NULL;
680     if (GenerateOpensslDsaKeyByCommSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
681         return HCF_ERR_CRYPTO_OPERATION;
682     }
683     HcfOpensslDsaPubKey *pubKey = NULL;
684     if (CreateDsaPubKey(dsa, &pubKey) != HCF_SUCCESS) {
685         OpensslDsaFree(dsa);
686         return HCF_ERR_MALLOC;
687     }
688 
689     if (OpensslDsaUpRef(dsa) != HCF_OPENSSL_SUCCESS) {
690         LOGE("Dup DSA failed.");
691         HcfPrintOpensslError();
692         HcfObjDestroy(pubKey);
693         return HCF_ERR_CRYPTO_OPERATION;
694     }
695 
696     HcfOpensslDsaPriKey *priKey = NULL;
697     if (CreateDsaPriKey(dsa, &priKey) != HCF_SUCCESS) {
698         OpensslDsaFree(dsa);
699         HcfObjDestroy(pubKey);
700         return HCF_ERR_MALLOC;
701     }
702 
703     if (CreateDsaKeyPair(pubKey, priKey, returnKeyPair) != HCF_SUCCESS) {
704         HcfObjDestroy(pubKey);
705         HcfObjDestroy(priKey);
706         return HCF_ERR_MALLOC;
707     }
708     return HCF_SUCCESS;
709 }
710 
CreateDsaPubKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfOpensslDsaPubKey ** returnPubKey)711 static HcfResult CreateDsaPubKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec,
712     HcfOpensslDsaPubKey **returnPubKey)
713 {
714     DSA *dsa = NULL;
715     if (GenerateOpensslDsaKeyByKeyPairSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
716         return HCF_ERR_CRYPTO_OPERATION;
717     }
718     if (CreateDsaPubKey(dsa, returnPubKey) != HCF_SUCCESS) {
719         OpensslDsaFree(dsa);
720         return HCF_ERR_MALLOC;
721     }
722     return HCF_SUCCESS;
723 }
724 
CreateDsaPriKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfOpensslDsaPriKey ** returnPriKey)725 static HcfResult CreateDsaPriKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec,
726     HcfOpensslDsaPriKey **returnPriKey)
727 {
728     DSA *dsa = NULL;
729     if (GenerateOpensslDsaKeyByKeyPairSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
730         return HCF_ERR_CRYPTO_OPERATION;
731     }
732     if (CreateDsaPriKey(dsa, returnPriKey) != HCF_SUCCESS) {
733         OpensslDsaFree(dsa);
734         return HCF_ERR_MALLOC;
735     }
736     return HCF_SUCCESS;
737 }
738 
CreateDsaKeyPairByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)739 static HcfResult CreateDsaKeyPairByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
740 {
741     HcfOpensslDsaPubKey *pubKey = NULL;
742     HcfResult ret = CreateDsaPubKeyByKeyPairSpec(paramsSpec, &pubKey);
743     if (ret != HCF_SUCCESS) {
744         return ret;
745     }
746 
747     HcfOpensslDsaPriKey *priKey = NULL;
748     ret = CreateDsaPriKeyByKeyPairSpec(paramsSpec, &priKey);
749     if (ret != HCF_SUCCESS) {
750         HcfObjDestroy(pubKey);
751         return ret;
752     }
753     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
754     if (ret != HCF_SUCCESS) {
755         HcfObjDestroy(pubKey);
756         HcfObjDestroy(priKey);
757         return ret;
758     }
759     return HCF_SUCCESS;
760 }
761 
CreateDsaKeyPairBySpec(const HcfAsyKeyParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)762 static HcfResult CreateDsaKeyPairBySpec(const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
763 {
764     if (paramsSpec->specType == HCF_COMMON_PARAMS_SPEC) {
765         return CreateDsaKeyPairByCommSpec((const HcfDsaCommParamsSpec *)paramsSpec, returnKeyPair);
766     } else {
767         return CreateDsaKeyPairByKeyPairSpec((const HcfDsaKeyPairParamsSpec *)paramsSpec, returnKeyPair);
768     }
769 }
770 
CreateDsaPubKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec * paramsSpec,HcfPubKey ** returnPubKey)771 static HcfResult CreateDsaPubKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey)
772 {
773     DSA *dsa = NULL;
774     if (GenerateOpensslDsaKeyByPubKeySpec(paramsSpec, &dsa) != HCF_SUCCESS) {
775         return HCF_ERR_CRYPTO_OPERATION;
776     }
777 
778     HcfOpensslDsaPubKey *pubKey = NULL;
779     if (CreateDsaPubKey(dsa, &pubKey) != HCF_SUCCESS) {
780         OpensslDsaFree(dsa);
781         return HCF_ERR_MALLOC;
782     }
783     *returnPubKey = (HcfPubKey *)pubKey;
784     return HCF_SUCCESS;
785 }
786 
ConvertDsaPubKey(const HcfBlob * pubKeyBlob,HcfOpensslDsaPubKey ** returnPubKey)787 static HcfResult ConvertDsaPubKey(const HcfBlob *pubKeyBlob, HcfOpensslDsaPubKey **returnPubKey)
788 {
789     const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data);
790     DSA *dsa = OpensslD2iDsaPubKey(NULL, &tmpData, pubKeyBlob->len);
791     if (dsa == NULL) {
792         LOGD("[error] D2i_DSA_PUBKEY fail.");
793         HcfPrintOpensslError();
794         return HCF_ERR_CRYPTO_OPERATION;
795     }
796     HcfResult ret = CreateDsaPubKey(dsa, returnPubKey);
797     if (ret != HCF_SUCCESS) {
798         LOGD("[error] Create DSA public key failed");
799         OpensslDsaFree(dsa);
800     }
801     return ret;
802 }
803 
ConvertDsaPriKey(const HcfBlob * priKeyBlob,HcfOpensslDsaPriKey ** returnPriKey)804 static HcfResult ConvertDsaPriKey(const HcfBlob *priKeyBlob, HcfOpensslDsaPriKey **returnPriKey)
805 {
806     const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data);
807     DSA *dsa = OpensslD2iDsaPrivateKey(NULL, &tmpData, priKeyBlob->len);
808     if (dsa == NULL) {
809         LOGD("[error] D2i_DSADSAPrivateKey fail.");
810         HcfPrintOpensslError();
811         return HCF_ERR_CRYPTO_OPERATION;
812     }
813     HcfResult ret = CreateDsaPriKey(dsa, returnPriKey);
814     if (ret != HCF_SUCCESS) {
815         LOGD("[error] Create DSA private key failed");
816         OpensslDsaFree(dsa);
817     }
818     return ret;
819 }
820 
ConvertDsaPubAndPriKey(const HcfBlob * pubKeyBlob,const HcfBlob * priKeyBlob,HcfOpensslDsaPubKey ** returnPubKey,HcfOpensslDsaPriKey ** returnPriKey)821 static HcfResult ConvertDsaPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob *priKeyBlob,
822     HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey)
823 {
824     if (pubKeyBlob != NULL) {
825         if (ConvertDsaPubKey(pubKeyBlob, returnPubKey) != HCF_SUCCESS) {
826             LOGD("[error] Convert DSA public key failed.");
827             return HCF_ERR_CRYPTO_OPERATION;
828         }
829     }
830     if (priKeyBlob != NULL) {
831         if (ConvertDsaPriKey(priKeyBlob, returnPriKey) != HCF_SUCCESS) {
832             LOGD("[error] Convert DSA private key failed.");
833             HcfObjDestroy(*returnPubKey);
834             *returnPubKey = NULL;
835             return HCF_ERR_CRYPTO_OPERATION;
836         }
837     }
838     return HCF_SUCCESS;
839 }
840 
EngineGenerateDsaKeyPair(HcfAsyKeyGeneratorSpi * self,HcfKeyPair ** returnKeyPair)841 static HcfResult EngineGenerateDsaKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnKeyPair)
842 {
843     if (self == NULL || returnKeyPair == NULL) {
844         LOGE("Invalid params.");
845         return HCF_INVALID_PARAMS;
846     }
847     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
848         LOGE("Class not match.");
849         return HCF_INVALID_PARAMS;
850     }
851     HcfAsyKeyGeneratorSpiDsaOpensslImpl *impl = (HcfAsyKeyGeneratorSpiDsaOpensslImpl *)self;
852 
853     HcfOpensslDsaPubKey *pubKey = NULL;
854     HcfOpensslDsaPriKey *priKey = NULL;
855     HcfResult ret = GenerateDsaPubAndPriKey(impl->bits, &pubKey, &priKey);
856     if (ret != HCF_SUCCESS) {
857         LOGE("Generate DSA pk and sk by openssl failed.");
858         return ret;
859     }
860 
861     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
862     if (ret != HCF_SUCCESS) {
863         HcfObjDestroy(pubKey);
864         HcfObjDestroy(priKey);
865         return ret;
866     }
867     return HCF_SUCCESS;
868 }
869 
EngineConvertDsaKey(HcfAsyKeyGeneratorSpi * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)870 static HcfResult EngineConvertDsaKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
871     HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
872 {
873     (void)params;
874     if ((self == NULL) || (returnKeyPair == NULL)) {
875         LOGE("Invalid input parameter.");
876         return HCF_INVALID_PARAMS;
877     }
878     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
879         LOGE("Class not match.");
880         return HCF_INVALID_PARAMS;
881     }
882     bool pubKeyValid = HcfIsBlobValid(pubKeyBlob);
883     bool priKeyValid = HcfIsBlobValid(priKeyBlob);
884     if ((!pubKeyValid) && (!priKeyValid)) {
885         LOGE("The private key and public key cannot both be NULL.");
886         return HCF_INVALID_PARAMS;
887     }
888 
889     HcfOpensslDsaPubKey *pubKey = NULL;
890     HcfOpensslDsaPriKey *priKey = NULL;
891     HcfBlob *inputPk = pubKeyValid ? pubKeyBlob : NULL;
892     HcfBlob *inputSk = priKeyValid ? priKeyBlob : NULL;
893     HcfResult ret = ConvertDsaPubAndPriKey(inputPk, inputSk, &pubKey, &priKey);
894     if (ret != HCF_SUCCESS) {
895         return ret;
896     }
897     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
898     if (ret != HCF_SUCCESS) {
899         HcfObjDestroy(pubKey);
900         HcfObjDestroy(priKey);
901     }
902     return ret;
903 }
904 
EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)905 static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self,
906     const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
907 {
908     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnKeyPair == NULL)) {
909         LOGE("Invalid input parameter.");
910         return HCF_INVALID_PARAMS;
911     }
912 
913     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
914         return HCF_INVALID_PARAMS;
915     }
916 
917     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) ||
918         ((paramsSpec->specType != HCF_COMMON_PARAMS_SPEC) && (paramsSpec->specType != HCF_KEY_PAIR_SPEC))) {
919         LOGE("Invalid params spec.");
920         return HCF_INVALID_PARAMS;
921     }
922     HcfResult ret = CreateDsaKeyPairBySpec(paramsSpec, returnKeyPair);
923     if (ret != HCF_SUCCESS) {
924         LOGE("Create DSA key pair by spec failed.");
925     }
926     return ret;
927 }
928 
EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfPubKey ** returnPubKey)929 static HcfResult EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self,
930     const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey)
931 {
932     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPubKey == NULL)) {
933         LOGE("Invalid input parameter.");
934         return HCF_INVALID_PARAMS;
935     }
936 
937     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
938         return HCF_INVALID_PARAMS;
939     }
940 
941     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) ||
942         ((paramsSpec->specType != HCF_PUBLIC_KEY_SPEC) && (paramsSpec->specType != HCF_KEY_PAIR_SPEC))) {
943         LOGE("Invalid params spec.");
944         return HCF_INVALID_PARAMS;
945     }
946 
947     HcfResult ret = CreateDsaPubKeyByPubKeySpec((const HcfDsaPubKeyParamsSpec *)paramsSpec, returnPubKey);
948     if (ret != HCF_SUCCESS) {
949         LOGE("Create DSA public key by spec failed.");
950     }
951     return ret;
952 }
953 
EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfPriKey ** returnPriKey)954 static HcfResult EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self,
955     const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey)
956 {
957     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) ||  (returnPriKey == NULL)) {
958         LOGE("Invalid input parameter.");
959         return HCF_INVALID_PARAMS;
960     }
961     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
962         return HCF_INVALID_PARAMS;
963     }
964     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) || (paramsSpec->specType != HCF_KEY_PAIR_SPEC)) {
965         LOGE("Invalid params spec.");
966         return HCF_INVALID_PARAMS;
967     }
968 
969     HcfOpensslDsaPriKey *dsaSk = NULL;
970     HcfResult ret = CreateDsaPriKeyByKeyPairSpec((const HcfDsaKeyPairParamsSpec *)paramsSpec, &dsaSk);
971     if (ret != HCF_SUCCESS) {
972         LOGE("Create DSA private key by spec failed.");
973     } else {
974         *returnPriKey = (HcfPriKey *)dsaSk;
975     }
976     return ret;
977 }
978 
HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams * params,HcfAsyKeyGeneratorSpi ** returnObj)979 HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj)
980 {
981     if (params == NULL || returnObj == NULL) {
982         LOGE("Invalid input parameter.");
983         return HCF_INVALID_PARAMS;
984     }
985     HcfAsyKeyGeneratorSpiDsaOpensslImpl *impl = (HcfAsyKeyGeneratorSpiDsaOpensslImpl *)HcfMalloc(
986         sizeof(HcfAsyKeyGeneratorSpiDsaOpensslImpl), 0);
987     if (impl == NULL) {
988         LOGE("Failed to allocate generator impl memroy.");
989         return HCF_ERR_MALLOC;
990     }
991     impl->bits = params->bits;
992     impl->base.base.getClass = GetDsaKeyGeneratorSpiClass;
993     impl->base.base.destroy = DestroyDsaKeyGeneratorSpiImpl;
994     impl->base.engineGenerateKeyPair = EngineGenerateDsaKeyPair;
995     impl->base.engineConvertKey = EngineConvertDsaKey;
996     impl->base.engineGenerateKeyPairBySpec = EngineGenerateDsaKeyPairBySpec;
997     impl->base.engineGeneratePubKeyBySpec = EngineGenerateDsaPubKeyBySpec;
998     impl->base.engineGeneratePriKeyBySpec = EngineGenerateDsaPriKeyBySpec;
999 
1000     *returnObj = (HcfAsyKeyGeneratorSpi *)impl;
1001     return HCF_SUCCESS;
1002 }
1003