• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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(const HcfPriKey * self,HcfParamsSpec * paramsSpec,const char * format,char ** returnString)218 static HcfResult GetDsaPriKeyEncodedPem(const HcfPriKey *self, HcfParamsSpec *paramsSpec, const char *format,
219     char **returnString)
220 {
221     (void)self;
222     (void)paramsSpec;
223     (void)format;
224     (void)returnString;
225     return HCF_INVALID_PARAMS;
226 }
227 
GetDsaPubKeyFormat(HcfKey * self)228 static const char *GetDsaPubKeyFormat(HcfKey *self)
229 {
230     if (self == NULL) {
231         LOGE("Invalid input parameter.");
232         return NULL;
233     }
234     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
235         return NULL;
236     }
237     return OPENSSL_DSA_PUBKEY_FORMAT;
238 }
239 
GetDsaPriKeyFormat(HcfKey * self)240 static const char *GetDsaPriKeyFormat(HcfKey *self)
241 {
242     if (self == NULL) {
243         LOGE("Invalid input parameter.");
244         return NULL;
245     }
246     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
247         return NULL;
248     }
249     return OPENSSL_DSA_PRIKEY_FORMAT;
250 }
251 
GetBigIntegerSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)252 static HcfResult GetBigIntegerSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item,
253     HcfBigInteger *returnBigInteger)
254 {
255     if (self ==  NULL || returnBigInteger == NULL) {
256         LOGE("Invalid input parameter.");
257         return HCF_INVALID_PARAMS;
258     }
259     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPubKeyClass())) {
260         LOGE("Invalid class of self.");
261         return HCF_INVALID_PARAMS;
262     }
263     HcfResult ret = HCF_SUCCESS;
264     HcfOpensslDsaPubKey *impl = (HcfOpensslDsaPubKey *)self;
265     DSA *dsaPk = impl->pk;
266     if (dsaPk == NULL) {
267         return HCF_INVALID_PARAMS;
268     }
269     switch (item) {
270         case DSA_P_BN:
271             ret = BigNumToBigInteger(OpensslDsaGet0P(dsaPk), returnBigInteger);
272             break;
273         case DSA_Q_BN:
274             ret = BigNumToBigInteger(OpensslDsaGet0Q(dsaPk), returnBigInteger);
275             break;
276         case DSA_G_BN:
277             ret = BigNumToBigInteger(OpensslDsaGet0G(dsaPk), returnBigInteger);
278             break;
279         case DSA_PK_BN:
280             ret = BigNumToBigInteger(OpensslDsaGet0PubKey(dsaPk), returnBigInteger);
281             break;
282         default:
283             LOGE("Input item is invalid");
284             ret = HCF_INVALID_PARAMS;
285             break;
286     }
287     return ret;
288 }
289 
GetBigIntegerSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)290 static HcfResult GetBigIntegerSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item,
291     HcfBigInteger *returnBigInteger)
292 {
293     if (self ==  NULL || returnBigInteger == NULL) {
294         LOGE("Invalid input parameter.");
295         return HCF_INVALID_PARAMS;
296     }
297     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
298         LOGE("Invalid class of self.");
299         return HCF_INVALID_PARAMS;
300     }
301     HcfResult ret = HCF_SUCCESS;
302     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
303     DSA *dsaSk = impl->sk;
304     if (dsaSk == NULL) {
305         return HCF_INVALID_PARAMS;
306     }
307     switch (item) {
308         case DSA_P_BN:
309             ret = BigNumToBigInteger(OpensslDsaGet0P(dsaSk), returnBigInteger);
310             break;
311         case DSA_Q_BN:
312             ret = BigNumToBigInteger(OpensslDsaGet0Q(dsaSk), returnBigInteger);
313             break;
314         case DSA_G_BN:
315             ret = BigNumToBigInteger(OpensslDsaGet0G(dsaSk), returnBigInteger);
316             break;
317         case DSA_SK_BN:
318             ret = BigNumToBigInteger(OpensslDsaGet0PrivKey(dsaSk), returnBigInteger);
319             break;
320         default:
321             LOGE("Input item is invalid");
322             ret = HCF_INVALID_PARAMS;
323             break;
324     }
325     return ret;
326 }
327 
GetIntSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,int * returnInt)328 static HcfResult GetIntSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item, int *returnInt)
329 {
330     (void)self;
331     (void)returnInt;
332     return HCF_NOT_SUPPORT;
333 }
334 
GetIntSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,int * returnInt)335 static HcfResult GetIntSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item, int *returnInt)
336 {
337     (void)self;
338     (void)returnInt;
339     return HCF_NOT_SUPPORT;
340 }
341 
GetStrSpecFromDsaPubKey(const HcfPubKey * self,const AsyKeySpecItem item,char ** returnString)342 static HcfResult GetStrSpecFromDsaPubKey(const HcfPubKey *self, const AsyKeySpecItem item, char **returnString)
343 {
344     (void)self;
345     (void)returnString;
346     return HCF_NOT_SUPPORT;
347 }
348 
GetStrSpecFromDsaPriKey(const HcfPriKey * self,const AsyKeySpecItem item,char ** returnString)349 static HcfResult GetStrSpecFromDsaPriKey(const HcfPriKey *self, const AsyKeySpecItem item, char **returnString)
350 {
351     (void)self;
352     (void)returnString;
353     return HCF_NOT_SUPPORT;
354 }
355 
ClearDsaPriKeyMem(HcfPriKey * self)356 static void ClearDsaPriKeyMem(HcfPriKey *self)
357 {
358     if (self == NULL) {
359         return;
360     }
361     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaPriKeyClass())) {
362         return;
363     }
364     HcfOpensslDsaPriKey *impl = (HcfOpensslDsaPriKey *)self;
365     OpensslDsaFree(impl->sk);
366     impl->sk = NULL;
367 }
368 
GetDsaPriKeyEncodedDer(const HcfPriKey * self,const char * format,HcfBlob * returnBlob)369 static HcfResult GetDsaPriKeyEncodedDer(const HcfPriKey *self, const char *format, HcfBlob *returnBlob)
370 {
371     (void)self;
372     (void)format;
373     (void)returnBlob;
374     return HCF_INVALID_PARAMS;
375 }
376 
GenerateDsaEvpKey(int32_t keyLen,EVP_PKEY ** ppkey)377 static HcfResult GenerateDsaEvpKey(int32_t keyLen, EVP_PKEY **ppkey)
378 {
379     EVP_PKEY_CTX *paramsCtx = NULL;
380     EVP_PKEY *paramsPkey = NULL;
381     EVP_PKEY_CTX *pkeyCtx = NULL;
382     HcfResult ret = HCF_SUCCESS;
383     do {
384         paramsCtx = OpensslEvpPkeyCtxNewId(EVP_PKEY_DSA, NULL);
385         if (paramsCtx == NULL) {
386             LOGE("Create params ctx failed.");
387             ret = HCF_ERR_MALLOC;
388             break;
389         }
390         if (OpensslEvpPkeyParamGenInit(paramsCtx) != HCF_OPENSSL_SUCCESS) {
391             LOGD("[error] Params ctx generate init failed.");
392             ret = HCF_ERR_CRYPTO_OPERATION;
393             break;
394         }
395         if (OpensslEvpPkeyCtxSetDsaParamgenBits(paramsCtx, keyLen) <= 0) {
396             LOGD("[error] Set length of bits to params ctx failed.");
397             ret = HCF_ERR_CRYPTO_OPERATION;
398             break;
399         }
400         if (OpensslEvpPkeyParamGen(paramsCtx, &paramsPkey) != HCF_OPENSSL_SUCCESS) {
401             LOGD("[error] Generate params pkey failed.");
402             ret = HCF_ERR_CRYPTO_OPERATION;
403             break;
404         }
405         pkeyCtx = OpensslEvpPkeyCtxNew(paramsPkey, NULL);
406         if (pkeyCtx == NULL) {
407             LOGD("[error] Create pkey ctx failed.");
408             ret = HCF_ERR_CRYPTO_OPERATION;
409             break;
410         }
411         if (OpensslEvpPkeyKeyGenInit(pkeyCtx) != HCF_OPENSSL_SUCCESS) {
412             LOGD("[error] Key ctx generate init failed.");
413             ret = HCF_ERR_CRYPTO_OPERATION;
414             break;
415         }
416         if (OpensslEvpPkeyKeyGen(pkeyCtx, ppkey) != HCF_OPENSSL_SUCCESS) {
417             LOGD("[error] Generate pkey failed.");
418             ret = HCF_ERR_CRYPTO_OPERATION;
419             break;
420         }
421     } while (0);
422     FreeCtx(paramsCtx, paramsPkey, pkeyCtx);
423     return ret;
424 }
425 
GetDsaPubKeyEncodedDer(const HcfPubKey * self,const char * format,HcfBlob * returnBlob)426 static HcfResult GetDsaPubKeyEncodedDer(const HcfPubKey *self, const char *format, HcfBlob *returnBlob)
427 {
428     (void)self;
429     (void)format;
430     (void)returnBlob;
431     return HCF_INVALID_PARAMS;
432 }
433 
FillOpensslDsaPubKeyFunc(HcfOpensslDsaPubKey * pk)434 static void FillOpensslDsaPubKeyFunc(HcfOpensslDsaPubKey *pk)
435 {
436     pk->base.base.base.destroy = DestroyDsaPubKey;
437     pk->base.base.base.getClass = GetDsaPubKeyClass;
438     pk->base.base.getAlgorithm = GetDsaPubKeyAlgorithm;
439     pk->base.base.getEncoded = GetDsaPubKeyEncoded;
440     pk->base.base.getEncodedPem = GetDsaPubKeyEncodedPem;
441     pk->base.base.getFormat = GetDsaPubKeyFormat;
442     pk->base.getAsyKeySpecBigInteger = GetBigIntegerSpecFromDsaPubKey;
443     pk->base.getAsyKeySpecInt = GetIntSpecFromDsaPubKey;
444     pk->base.getAsyKeySpecString = GetStrSpecFromDsaPubKey;
445     pk->base.getEncodedDer = GetDsaPubKeyEncodedDer;
446 }
447 
FillOpensslDsaPriKeyFunc(HcfOpensslDsaPriKey * sk)448 static void FillOpensslDsaPriKeyFunc(HcfOpensslDsaPriKey *sk)
449 {
450     sk->base.base.base.destroy = DestroyDsaPriKey;
451     sk->base.base.base.getClass = GetDsaPriKeyClass;
452     sk->base.base.getAlgorithm = GetDsaPriKeyAlgorithm;
453     sk->base.base.getEncoded = GetDsaPriKeyEncoded;
454     sk->base.getEncodedPem = GetDsaPriKeyEncodedPem;
455     sk->base.base.getFormat = GetDsaPriKeyFormat;
456     sk->base.getAsyKeySpecBigInteger = GetBigIntegerSpecFromDsaPriKey;
457     sk->base.getAsyKeySpecInt = GetIntSpecFromDsaPriKey;
458     sk->base.getAsyKeySpecString = GetStrSpecFromDsaPriKey;
459     sk->base.clearMem = ClearDsaPriKeyMem;
460     sk->base.getEncodedDer = GetDsaPriKeyEncodedDer;
461 }
462 
CreateDsaPubKey(DSA * pk,HcfOpensslDsaPubKey ** returnPubKey)463 static HcfResult CreateDsaPubKey(DSA *pk, HcfOpensslDsaPubKey **returnPubKey)
464 {
465     HcfOpensslDsaPubKey *dsaPubKey = (HcfOpensslDsaPubKey *)HcfMalloc(sizeof(HcfOpensslDsaPubKey), 0);
466     if (dsaPubKey == NULL) {
467         LOGE("Failed to allocate DSA public key memory.");
468         return HCF_ERR_MALLOC;
469     }
470     FillOpensslDsaPubKeyFunc(dsaPubKey);
471     dsaPubKey->pk = pk;
472 
473     *returnPubKey = dsaPubKey;
474     return HCF_SUCCESS;
475 }
476 
CreateDsaPriKey(DSA * sk,HcfOpensslDsaPriKey ** returnPriKey)477 static HcfResult CreateDsaPriKey(DSA *sk, HcfOpensslDsaPriKey **returnPriKey)
478 {
479     HcfOpensslDsaPriKey *dsaPriKey = (HcfOpensslDsaPriKey *)HcfMalloc(sizeof(HcfOpensslDsaPriKey), 0);
480     if (dsaPriKey == NULL) {
481         LOGE("Failed to allocate DSA private key memory.");
482         return HCF_ERR_MALLOC;
483     }
484     FillOpensslDsaPriKeyFunc(dsaPriKey);
485     dsaPriKey->sk = sk;
486 
487     *returnPriKey = dsaPriKey;
488     return HCF_SUCCESS;
489 }
490 
CreateDsaKeyPair(const HcfOpensslDsaPubKey * pubKey,const HcfOpensslDsaPriKey * priKey,HcfKeyPair ** returnKeyPair)491 static HcfResult CreateDsaKeyPair(const HcfOpensslDsaPubKey *pubKey, const HcfOpensslDsaPriKey *priKey,
492     HcfKeyPair **returnKeyPair)
493 {
494     HcfOpensslDsaKeyPair *keyPair = (HcfOpensslDsaKeyPair *)HcfMalloc(sizeof(HcfOpensslDsaKeyPair), 0);
495     if (keyPair == NULL) {
496         LOGE("Failed to allocate keyPair memory.");
497         return HCF_ERR_MALLOC;
498     }
499     keyPair->base.base.getClass = GetDsaKeyPairClass;
500     keyPair->base.base.destroy = DestroyDsaKeyPair;
501     keyPair->base.pubKey = (HcfPubKey *)pubKey;
502     keyPair->base.priKey = (HcfPriKey *)priKey;
503 
504     *returnKeyPair = (HcfKeyPair *)keyPair;
505     return HCF_SUCCESS;
506 }
507 
GeneratePubKeyByPkey(EVP_PKEY * pkey,HcfOpensslDsaPubKey ** returnPubKey)508 static HcfResult GeneratePubKeyByPkey(EVP_PKEY *pkey, HcfOpensslDsaPubKey **returnPubKey)
509 {
510     DSA *pk = OpensslEvpPkeyGet1Dsa(pkey);
511     if (pk == NULL) {
512         LOGD("[error] Get das public key from pkey failed");
513         HcfPrintOpensslError();
514         return HCF_ERR_CRYPTO_OPERATION;
515     }
516     HcfResult ret = CreateDsaPubKey(pk, returnPubKey);
517     if (ret != HCF_SUCCESS) {
518         LOGD("[error] Create DSA public key failed");
519         OpensslDsaFree(pk);
520     }
521     return ret;
522 }
523 
GeneratePriKeyByPkey(EVP_PKEY * pkey,HcfOpensslDsaPriKey ** returnPriKey)524 static HcfResult GeneratePriKeyByPkey(EVP_PKEY *pkey, HcfOpensslDsaPriKey **returnPriKey)
525 {
526     DSA *sk = OpensslEvpPkeyGet1Dsa(pkey);
527     if (sk == NULL) {
528         LOGD("[error] Get DSA private key from pkey failed");
529         HcfPrintOpensslError();
530         return HCF_ERR_CRYPTO_OPERATION;
531     }
532     HcfResult ret = CreateDsaPriKey(sk, returnPriKey);
533     if (ret != HCF_SUCCESS) {
534         LOGD("[error] Create DSA private key failed");
535         OpensslDsaFree(sk);
536     }
537     return ret;
538 }
539 
GenerateDsaPubAndPriKey(int32_t keyLen,HcfOpensslDsaPubKey ** returnPubKey,HcfOpensslDsaPriKey ** returnPriKey)540 static HcfResult GenerateDsaPubAndPriKey(int32_t keyLen, HcfOpensslDsaPubKey **returnPubKey,
541     HcfOpensslDsaPriKey **returnPriKey)
542 {
543     EVP_PKEY *pkey = NULL;
544     HcfResult ret = GenerateDsaEvpKey(keyLen, &pkey);
545     if (ret != HCF_SUCCESS) {
546         LOGD("[error] Generate DSA EVP_PKEY failed.");
547         return ret;
548     }
549 
550     ret = GeneratePubKeyByPkey(pkey, returnPubKey);
551     if (ret != HCF_SUCCESS) {
552         OpensslEvpPkeyFree(pkey);
553         return ret;
554     }
555 
556     ret = GeneratePriKeyByPkey(pkey, returnPriKey);
557     if (ret != HCF_SUCCESS) {
558         HcfObjDestroy(*returnPubKey);
559         *returnPubKey = NULL;
560         OpensslEvpPkeyFree(pkey);
561         return HCF_ERR_CRYPTO_OPERATION;
562     }
563 
564     OpensslEvpPkeyFree(pkey);
565     return ret;
566 }
567 
ConvertCommSpec2Bn(const HcfDsaCommParamsSpec * paramsSpec,BIGNUM ** p,BIGNUM ** q,BIGNUM ** g)568 static HcfResult ConvertCommSpec2Bn(const HcfDsaCommParamsSpec *paramsSpec, BIGNUM **p, BIGNUM **q, BIGNUM **g)
569 {
570     if (BigIntegerToBigNum(&(paramsSpec->p), p) != HCF_SUCCESS) {
571         LOGD("[error] Get openssl BN p failed");
572         return HCF_ERR_CRYPTO_OPERATION;
573     }
574     if (BigIntegerToBigNum(&(paramsSpec->q), q) != HCF_SUCCESS)  {
575         LOGD("[error] Get openssl BN q failed");
576         OpensslBnFree(*p);
577         *p = NULL;
578         return HCF_ERR_CRYPTO_OPERATION;
579     }
580     if (BigIntegerToBigNum(&(paramsSpec->g), g) != HCF_SUCCESS) {
581         LOGD("[error] Get openssl BN g failed");
582         OpensslBnFree(*p);
583         *p = NULL;
584         OpensslBnFree(*q);
585         *q = NULL;
586         return HCF_ERR_CRYPTO_OPERATION;
587     }
588     return HCF_SUCCESS;
589 }
590 
CreateOpensslDsaKey(const HcfDsaCommParamsSpec * paramsSpec,BIGNUM * pk,BIGNUM * sk,DSA ** returnDsa)591 static HcfResult CreateOpensslDsaKey(const HcfDsaCommParamsSpec *paramsSpec, BIGNUM *pk, BIGNUM *sk, DSA **returnDsa)
592 {
593     BIGNUM *p = NULL;
594     BIGNUM *q = NULL;
595     BIGNUM *g = NULL;
596     if (ConvertCommSpec2Bn(paramsSpec, &p, &q, &g)!= HCF_SUCCESS) {
597         return HCF_ERR_CRYPTO_OPERATION;
598     }
599     DSA *dsa = OpensslDsaNew();
600     if (dsa == NULL) {
601         FreeCommSpecBn(p, q, g);
602         LOGD("[error] Openssl DSA new failed");
603         HcfPrintOpensslError();
604         return HCF_ERR_CRYPTO_OPERATION;
605     }
606     if (OpensslDsaSet0Pqg(dsa, p, q, g) != HCF_OPENSSL_SUCCESS) {
607         LOGD("[error] Openssl DSA set pqg failed");
608         FreeCommSpecBn(p, q, g);
609         HcfPrintOpensslError();
610         OpensslDsaFree(dsa);
611         return HCF_ERR_CRYPTO_OPERATION;
612     }
613     if ((pk == NULL) && (sk == NULL)) {
614         *returnDsa = dsa;
615         return HCF_SUCCESS;
616     }
617     if (OpensslDsaSet0Key(dsa, pk, sk) != HCF_OPENSSL_SUCCESS) {
618         LOGD("[error] Openssl DSA set pqg failed");
619         HcfPrintOpensslError();
620         OpensslDsaFree(dsa);
621         return HCF_ERR_CRYPTO_OPERATION;
622     }
623     *returnDsa = dsa;
624     return HCF_SUCCESS;
625 }
626 
GenerateOpensslDsaKeyByCommSpec(const HcfDsaCommParamsSpec * paramsSpec,DSA ** returnDsa)627 static HcfResult GenerateOpensslDsaKeyByCommSpec(const HcfDsaCommParamsSpec *paramsSpec, DSA **returnDsa)
628 {
629     if (CreateOpensslDsaKey(paramsSpec, NULL, NULL, returnDsa) != HCF_SUCCESS) {
630         return HCF_ERR_CRYPTO_OPERATION;
631     }
632 
633     if (OpensslDsaGenerateKey(*returnDsa) != HCF_OPENSSL_SUCCESS) {
634         LOGD("[error] Openssl DSA generate key failed");
635         HcfPrintOpensslError();
636         OpensslDsaFree(*returnDsa);
637         *returnDsa = NULL;
638         return HCF_ERR_CRYPTO_OPERATION;
639     }
640     return HCF_SUCCESS;
641 }
642 
GenerateOpensslDsaKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec * paramsSpec,DSA ** returnDsa)643 static HcfResult GenerateOpensslDsaKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec *paramsSpec, DSA **returnDsa)
644 {
645     BIGNUM *pubKey = NULL;
646     if (BigIntegerToBigNum(&(paramsSpec->pk), &pubKey) != HCF_SUCCESS) {
647         LOGD("[error] Get openssl BN pk failed");
648         return HCF_ERR_CRYPTO_OPERATION;
649     }
650 
651     if (CreateOpensslDsaKey(&(paramsSpec->base), pubKey, NULL, returnDsa) != HCF_SUCCESS) {
652         OpensslBnFree(pubKey);
653         return HCF_ERR_CRYPTO_OPERATION;
654     }
655     return HCF_SUCCESS;
656 }
657 
GenerateOpensslDsaKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,DSA ** returnDsa)658 static HcfResult GenerateOpensslDsaKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec, DSA **returnDsa)
659 {
660     BIGNUM *pubKey = NULL;
661     BIGNUM *priKey = NULL;
662     if (BigIntegerToBigNum(&(paramsSpec->pk), &pubKey) != HCF_SUCCESS) {
663         LOGD("[error] Get openssl BN pk failed");
664         return HCF_ERR_CRYPTO_OPERATION;
665     }
666     if (BigIntegerToBigNum(&(paramsSpec->sk), &priKey) != HCF_SUCCESS) {
667         LOGD("[error] Get openssl BN sk failed");
668         OpensslBnFree(pubKey);
669         return HCF_ERR_CRYPTO_OPERATION;
670     }
671     if (CreateOpensslDsaKey(&(paramsSpec->base), pubKey, priKey, returnDsa) != HCF_SUCCESS) {
672         OpensslBnFree(pubKey);
673         OpensslBnFree(priKey);
674         return HCF_ERR_CRYPTO_OPERATION;
675     }
676     return HCF_SUCCESS;
677 }
678 
CreateDsaKeyPairByCommSpec(const HcfDsaCommParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)679 static HcfResult CreateDsaKeyPairByCommSpec(const HcfDsaCommParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
680 {
681     DSA *dsa = NULL;
682     if (GenerateOpensslDsaKeyByCommSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
683         return HCF_ERR_CRYPTO_OPERATION;
684     }
685     HcfOpensslDsaPubKey *pubKey = NULL;
686     if (CreateDsaPubKey(dsa, &pubKey) != HCF_SUCCESS) {
687         OpensslDsaFree(dsa);
688         return HCF_ERR_MALLOC;
689     }
690 
691     if (OpensslDsaUpRef(dsa) != HCF_OPENSSL_SUCCESS) {
692         LOGE("Dup DSA failed.");
693         HcfPrintOpensslError();
694         HcfObjDestroy(pubKey);
695         pubKey = NULL;
696         return HCF_ERR_CRYPTO_OPERATION;
697     }
698 
699     HcfOpensslDsaPriKey *priKey = NULL;
700     if (CreateDsaPriKey(dsa, &priKey) != HCF_SUCCESS) {
701         OpensslDsaFree(dsa);
702         HcfObjDestroy(pubKey);
703         pubKey = NULL;
704         return HCF_ERR_MALLOC;
705     }
706 
707     if (CreateDsaKeyPair(pubKey, priKey, returnKeyPair) != HCF_SUCCESS) {
708         HcfObjDestroy(pubKey);
709         pubKey = NULL;
710         HcfObjDestroy(priKey);
711         priKey = NULL;
712         return HCF_ERR_MALLOC;
713     }
714     return HCF_SUCCESS;
715 }
716 
CreateDsaPubKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfOpensslDsaPubKey ** returnPubKey)717 static HcfResult CreateDsaPubKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec,
718     HcfOpensslDsaPubKey **returnPubKey)
719 {
720     DSA *dsa = NULL;
721     if (GenerateOpensslDsaKeyByKeyPairSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
722         return HCF_ERR_CRYPTO_OPERATION;
723     }
724     if (CreateDsaPubKey(dsa, returnPubKey) != HCF_SUCCESS) {
725         OpensslDsaFree(dsa);
726         return HCF_ERR_MALLOC;
727     }
728     return HCF_SUCCESS;
729 }
730 
CreateDsaPriKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfOpensslDsaPriKey ** returnPriKey)731 static HcfResult CreateDsaPriKeyByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec,
732     HcfOpensslDsaPriKey **returnPriKey)
733 {
734     DSA *dsa = NULL;
735     if (GenerateOpensslDsaKeyByKeyPairSpec(paramsSpec, &dsa) != HCF_SUCCESS) {
736         return HCF_ERR_CRYPTO_OPERATION;
737     }
738     if (CreateDsaPriKey(dsa, returnPriKey) != HCF_SUCCESS) {
739         OpensslDsaFree(dsa);
740         return HCF_ERR_MALLOC;
741     }
742     return HCF_SUCCESS;
743 }
744 
CreateDsaKeyPairByKeyPairSpec(const HcfDsaKeyPairParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)745 static HcfResult CreateDsaKeyPairByKeyPairSpec(const HcfDsaKeyPairParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
746 {
747     HcfOpensslDsaPubKey *pubKey = NULL;
748     HcfResult ret = CreateDsaPubKeyByKeyPairSpec(paramsSpec, &pubKey);
749     if (ret != HCF_SUCCESS) {
750         return ret;
751     }
752 
753     HcfOpensslDsaPriKey *priKey = NULL;
754     ret = CreateDsaPriKeyByKeyPairSpec(paramsSpec, &priKey);
755     if (ret != HCF_SUCCESS) {
756         HcfObjDestroy(pubKey);
757         pubKey = NULL;
758         return ret;
759     }
760     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
761     if (ret != HCF_SUCCESS) {
762         HcfObjDestroy(pubKey);
763         pubKey = NULL;
764         HcfObjDestroy(priKey);
765         priKey = NULL;
766         return ret;
767     }
768     return HCF_SUCCESS;
769 }
770 
CreateDsaKeyPairBySpec(const HcfAsyKeyParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)771 static HcfResult CreateDsaKeyPairBySpec(const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
772 {
773     if (paramsSpec->specType == HCF_COMMON_PARAMS_SPEC) {
774         return CreateDsaKeyPairByCommSpec((const HcfDsaCommParamsSpec *)paramsSpec, returnKeyPair);
775     } else {
776         return CreateDsaKeyPairByKeyPairSpec((const HcfDsaKeyPairParamsSpec *)paramsSpec, returnKeyPair);
777     }
778 }
779 
CreateDsaPubKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec * paramsSpec,HcfPubKey ** returnPubKey)780 static HcfResult CreateDsaPubKeyByPubKeySpec(const HcfDsaPubKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey)
781 {
782     DSA *dsa = NULL;
783     if (GenerateOpensslDsaKeyByPubKeySpec(paramsSpec, &dsa) != HCF_SUCCESS) {
784         return HCF_ERR_CRYPTO_OPERATION;
785     }
786 
787     HcfOpensslDsaPubKey *pubKey = NULL;
788     if (CreateDsaPubKey(dsa, &pubKey) != HCF_SUCCESS) {
789         OpensslDsaFree(dsa);
790         return HCF_ERR_MALLOC;
791     }
792     *returnPubKey = (HcfPubKey *)pubKey;
793     return HCF_SUCCESS;
794 }
795 
ConvertDsaPubKey(const HcfBlob * pubKeyBlob,HcfOpensslDsaPubKey ** returnPubKey)796 static HcfResult ConvertDsaPubKey(const HcfBlob *pubKeyBlob, HcfOpensslDsaPubKey **returnPubKey)
797 {
798     const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data);
799     DSA *dsa = OpensslD2iDsaPubKey(NULL, &tmpData, pubKeyBlob->len);
800     if (dsa == NULL) {
801         LOGD("[error] D2i_DSA_PUBKEY fail.");
802         HcfPrintOpensslError();
803         return HCF_ERR_CRYPTO_OPERATION;
804     }
805     HcfResult ret = CreateDsaPubKey(dsa, returnPubKey);
806     if (ret != HCF_SUCCESS) {
807         LOGD("[error] Create DSA public key failed");
808         OpensslDsaFree(dsa);
809     }
810     return ret;
811 }
812 
ConvertDsaPriKey(const HcfBlob * priKeyBlob,HcfOpensslDsaPriKey ** returnPriKey)813 static HcfResult ConvertDsaPriKey(const HcfBlob *priKeyBlob, HcfOpensslDsaPriKey **returnPriKey)
814 {
815     const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data);
816     DSA *dsa = OpensslD2iDsaPrivateKey(NULL, &tmpData, priKeyBlob->len);
817     if (dsa == NULL) {
818         LOGD("[error] D2i_DSADSAPrivateKey fail.");
819         HcfPrintOpensslError();
820         return HCF_ERR_CRYPTO_OPERATION;
821     }
822     HcfResult ret = CreateDsaPriKey(dsa, returnPriKey);
823     if (ret != HCF_SUCCESS) {
824         LOGD("[error] Create DSA private key failed");
825         OpensslDsaFree(dsa);
826     }
827     return ret;
828 }
829 
ConvertDsaPubAndPriKey(const HcfBlob * pubKeyBlob,const HcfBlob * priKeyBlob,HcfOpensslDsaPubKey ** returnPubKey,HcfOpensslDsaPriKey ** returnPriKey)830 static HcfResult ConvertDsaPubAndPriKey(const HcfBlob *pubKeyBlob, const HcfBlob *priKeyBlob,
831     HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey)
832 {
833     if (pubKeyBlob != NULL) {
834         if (ConvertDsaPubKey(pubKeyBlob, returnPubKey) != HCF_SUCCESS) {
835             LOGD("[error] Convert DSA public key failed.");
836             return HCF_ERR_CRYPTO_OPERATION;
837         }
838     }
839     if (priKeyBlob != NULL) {
840         if (ConvertDsaPriKey(priKeyBlob, returnPriKey) != HCF_SUCCESS) {
841             LOGD("[error] Convert DSA private key failed.");
842             HcfObjDestroy(*returnPubKey);
843             *returnPubKey = NULL;
844             return HCF_ERR_CRYPTO_OPERATION;
845         }
846     }
847     return HCF_SUCCESS;
848 }
849 
EngineGenerateDsaKeyPair(HcfAsyKeyGeneratorSpi * self,HcfKeyPair ** returnKeyPair)850 static HcfResult EngineGenerateDsaKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnKeyPair)
851 {
852     if (self == NULL || returnKeyPair == NULL) {
853         LOGE("Invalid params.");
854         return HCF_INVALID_PARAMS;
855     }
856     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
857         LOGE("Class not match.");
858         return HCF_INVALID_PARAMS;
859     }
860     HcfAsyKeyGeneratorSpiDsaOpensslImpl *impl = (HcfAsyKeyGeneratorSpiDsaOpensslImpl *)self;
861 
862     HcfOpensslDsaPubKey *pubKey = NULL;
863     HcfOpensslDsaPriKey *priKey = NULL;
864     HcfResult ret = GenerateDsaPubAndPriKey(impl->bits, &pubKey, &priKey);
865     if (ret != HCF_SUCCESS) {
866         LOGE("Generate DSA pk and sk by openssl failed.");
867         return ret;
868     }
869 
870     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
871     if (ret != HCF_SUCCESS) {
872         HcfObjDestroy(pubKey);
873         pubKey = NULL;
874         HcfObjDestroy(priKey);
875         priKey = NULL;
876         return ret;
877     }
878     return HCF_SUCCESS;
879 }
880 
EngineConvertDsaKey(HcfAsyKeyGeneratorSpi * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)881 static HcfResult EngineConvertDsaKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
882     HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
883 {
884     (void)params;
885     if ((self == NULL) || (returnKeyPair == NULL)) {
886         LOGE("Invalid input parameter.");
887         return HCF_INVALID_PARAMS;
888     }
889     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
890         LOGE("Class not match.");
891         return HCF_INVALID_PARAMS;
892     }
893     bool pubKeyValid = HcfIsBlobValid(pubKeyBlob);
894     bool priKeyValid = HcfIsBlobValid(priKeyBlob);
895     if ((!pubKeyValid) && (!priKeyValid)) {
896         LOGE("The private key and public key cannot both be NULL.");
897         return HCF_INVALID_PARAMS;
898     }
899 
900     HcfOpensslDsaPubKey *pubKey = NULL;
901     HcfOpensslDsaPriKey *priKey = NULL;
902     HcfBlob *inputPk = pubKeyValid ? pubKeyBlob : NULL;
903     HcfBlob *inputSk = priKeyValid ? priKeyBlob : NULL;
904     HcfResult ret = ConvertDsaPubAndPriKey(inputPk, inputSk, &pubKey, &priKey);
905     if (ret != HCF_SUCCESS) {
906         return ret;
907     }
908     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
909     if (ret != HCF_SUCCESS) {
910         HcfObjDestroy(pubKey);
911         pubKey = NULL;
912         HcfObjDestroy(priKey);
913         priKey = NULL;
914     }
915     return ret;
916 }
917 
ConvertDsaPemPubKey(const char * pubKeyStr,HcfOpensslDsaPubKey ** returnPubKey)918 static HcfResult ConvertDsaPemPubKey(const char *pubKeyStr, HcfOpensslDsaPubKey **returnPubKey)
919 {
920     EVP_PKEY *pkey = NULL;
921     const char *keyType = "DSA";
922     HcfResult ret = ConvertPubPemStrToKey(&pkey, keyType, EVP_PKEY_PUBLIC_KEY, pubKeyStr);
923     if (ret != HCF_SUCCESS) {
924         LOGE("Convert dsa pem public key failed.");
925         return ret;
926     }
927 
928     DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey);
929     OpensslEvpPkeyFree(pkey);
930     if (dsa == NULL) {
931         LOGE("Pkey to dsa key failed.");
932         HcfPrintOpensslError();
933         return HCF_ERR_CRYPTO_OPERATION;
934     }
935 
936     ret = CreateDsaPubKey(dsa, returnPubKey);
937     if (ret != HCF_SUCCESS) {
938         LOGE("Create dsa public key failed");
939         OpensslDsaFree(dsa);
940     }
941     return ret;
942 }
943 
ConvertDsaPemPriKey(const char * priKeyStr,HcfOpensslDsaPriKey ** returnPriKey)944 static HcfResult ConvertDsaPemPriKey(const char *priKeyStr, HcfOpensslDsaPriKey **returnPriKey)
945 {
946     EVP_PKEY *pkey = NULL;
947     const char *keyType = "DSA";
948     HcfResult ret = ConvertPriPemStrToKey(priKeyStr, &pkey, keyType);
949     if (ret != HCF_SUCCESS) {
950         LOGE("Convert dsa pem private key failed.");
951         return ret;
952     }
953 
954     DSA *dsa = OpensslEvpPkeyGet1Dsa(pkey);
955     OpensslEvpPkeyFree(pkey);
956     if (dsa == NULL) {
957         LOGE("Pkey to dsa key failed.");
958         HcfPrintOpensslError();
959         return HCF_ERR_CRYPTO_OPERATION;
960     }
961 
962     ret = CreateDsaPriKey(dsa, returnPriKey);
963     if (ret != HCF_SUCCESS) {
964         LOGE("Create dsa private key failed");
965         OpensslDsaFree(dsa);
966     }
967 
968     return ret;
969 }
970 
ConvertDsaPemPubAndPriKey(const char * pubKeyStr,const char * priKeyStr,HcfOpensslDsaPubKey ** returnPubKey,HcfOpensslDsaPriKey ** returnPriKey)971 static HcfResult ConvertDsaPemPubAndPriKey(const char *pubKeyStr, const char *priKeyStr,
972     HcfOpensslDsaPubKey **returnPubKey, HcfOpensslDsaPriKey **returnPriKey)
973 {
974     if (pubKeyStr != NULL && strlen(pubKeyStr) != 0) {
975         if (ConvertDsaPemPubKey(pubKeyStr, returnPubKey) != HCF_SUCCESS) {
976             LOGE("Convert dsa pem public key failed.");
977             return HCF_ERR_CRYPTO_OPERATION;
978         }
979     }
980 
981     if (priKeyStr != NULL && strlen(priKeyStr) != 0) {
982         if (ConvertDsaPemPriKey(priKeyStr, returnPriKey) != HCF_SUCCESS) {
983             LOGE("Convert dsa pem private key failed.");
984             HcfObjDestroy(*returnPubKey);
985             *returnPubKey = NULL;
986             return HCF_ERR_CRYPTO_OPERATION;
987         }
988     }
989     return HCF_SUCCESS;
990 }
991 
EngineConvertDsaPemKey(HcfAsyKeyGeneratorSpi * self,HcfParamsSpec * params,const char * pubKeyStr,const char * priKeyStr,HcfKeyPair ** returnKeyPair)992 static HcfResult EngineConvertDsaPemKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, const char *pubKeyStr,
993     const char *priKeyStr, HcfKeyPair **returnKeyPair)
994 {
995     (void)params;
996     if ((self == NULL) || (returnKeyPair == NULL) || ((pubKeyStr == NULL) && (priKeyStr == NULL))) {
997         LOGE("Invalid input parameter.");
998         return HCF_INVALID_PARAMS;
999     }
1000     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
1001         LOGE("Class not match.");
1002         return HCF_INVALID_PARAMS;
1003     }
1004 
1005     HcfOpensslDsaPubKey *pubKey = NULL;
1006     HcfOpensslDsaPriKey *priKey = NULL;
1007 
1008     HcfResult ret = ConvertDsaPemPubAndPriKey(pubKeyStr, priKeyStr, &pubKey, &priKey);
1009     if (ret != HCF_SUCCESS) {
1010         return ret;
1011     }
1012 
1013     ret = CreateDsaKeyPair(pubKey, priKey, returnKeyPair);
1014     if (ret != HCF_SUCCESS) {
1015         HcfObjDestroy(pubKey);
1016         pubKey = NULL;
1017         HcfObjDestroy(priKey);
1018         priKey = NULL;
1019     }
1020 
1021     return ret;
1022 }
1023 
EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfKeyPair ** returnKeyPair)1024 static HcfResult EngineGenerateDsaKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self,
1025     const HcfAsyKeyParamsSpec *paramsSpec, HcfKeyPair **returnKeyPair)
1026 {
1027     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnKeyPair == NULL)) {
1028         LOGE("Invalid input parameter.");
1029         return HCF_INVALID_PARAMS;
1030     }
1031 
1032     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
1033         return HCF_INVALID_PARAMS;
1034     }
1035 
1036     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) ||
1037         ((paramsSpec->specType != HCF_COMMON_PARAMS_SPEC) && (paramsSpec->specType != HCF_KEY_PAIR_SPEC))) {
1038         LOGE("Invalid params spec.");
1039         return HCF_INVALID_PARAMS;
1040     }
1041     HcfResult ret = CreateDsaKeyPairBySpec(paramsSpec, returnKeyPair);
1042     if (ret != HCF_SUCCESS) {
1043         LOGE("Create DSA key pair by spec failed.");
1044     }
1045     return ret;
1046 }
1047 
EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfPubKey ** returnPubKey)1048 static HcfResult EngineGenerateDsaPubKeyBySpec(const HcfAsyKeyGeneratorSpi *self,
1049     const HcfAsyKeyParamsSpec *paramsSpec, HcfPubKey **returnPubKey)
1050 {
1051     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) || (returnPubKey == NULL)) {
1052         LOGE("Invalid input parameter.");
1053         return HCF_INVALID_PARAMS;
1054     }
1055 
1056     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
1057         return HCF_INVALID_PARAMS;
1058     }
1059 
1060     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) ||
1061         ((paramsSpec->specType != HCF_PUBLIC_KEY_SPEC) && (paramsSpec->specType != HCF_KEY_PAIR_SPEC))) {
1062         LOGE("Invalid params spec.");
1063         return HCF_INVALID_PARAMS;
1064     }
1065 
1066     HcfResult ret = CreateDsaPubKeyByPubKeySpec((const HcfDsaPubKeyParamsSpec *)paramsSpec, returnPubKey);
1067     if (ret != HCF_SUCCESS) {
1068         LOGE("Create DSA public key by spec failed.");
1069     }
1070     return ret;
1071 }
1072 
EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * paramsSpec,HcfPriKey ** returnPriKey)1073 static HcfResult EngineGenerateDsaPriKeyBySpec(const HcfAsyKeyGeneratorSpi *self,
1074     const HcfAsyKeyParamsSpec *paramsSpec, HcfPriKey **returnPriKey)
1075 {
1076     if ((self == NULL) || (paramsSpec == NULL) || (paramsSpec->algName == NULL) ||  (returnPriKey == NULL)) {
1077         LOGE("Invalid input parameter.");
1078         return HCF_INVALID_PARAMS;
1079     }
1080     if (!HcfIsClassMatch((HcfObjectBase *)self, GetDsaKeyGeneratorSpiClass())) {
1081         return HCF_INVALID_PARAMS;
1082     }
1083     if ((strcmp(paramsSpec->algName, ALGORITHM_NAME_DSA) != 0) || (paramsSpec->specType != HCF_KEY_PAIR_SPEC)) {
1084         LOGE("Invalid params spec.");
1085         return HCF_INVALID_PARAMS;
1086     }
1087 
1088     HcfOpensslDsaPriKey *dsaSk = NULL;
1089     HcfResult ret = CreateDsaPriKeyByKeyPairSpec((const HcfDsaKeyPairParamsSpec *)paramsSpec, &dsaSk);
1090     if (ret != HCF_SUCCESS) {
1091         LOGE("Create DSA private key by spec failed.");
1092     } else {
1093         *returnPriKey = (HcfPriKey *)dsaSk;
1094     }
1095     return ret;
1096 }
1097 
HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams * params,HcfAsyKeyGeneratorSpi ** returnObj)1098 HcfResult HcfAsyKeyGeneratorSpiDsaCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj)
1099 {
1100     if (params == NULL || returnObj == NULL) {
1101         LOGE("Invalid input parameter.");
1102         return HCF_INVALID_PARAMS;
1103     }
1104     HcfAsyKeyGeneratorSpiDsaOpensslImpl *impl = (HcfAsyKeyGeneratorSpiDsaOpensslImpl *)HcfMalloc(
1105         sizeof(HcfAsyKeyGeneratorSpiDsaOpensslImpl), 0);
1106     if (impl == NULL) {
1107         LOGE("Failed to allocate generator impl memroy.");
1108         return HCF_ERR_MALLOC;
1109     }
1110     impl->bits = params->bits;
1111     impl->base.base.getClass = GetDsaKeyGeneratorSpiClass;
1112     impl->base.base.destroy = DestroyDsaKeyGeneratorSpiImpl;
1113     impl->base.engineGenerateKeyPair = EngineGenerateDsaKeyPair;
1114     impl->base.engineConvertKey = EngineConvertDsaKey;
1115     impl->base.engineConvertPemKey = EngineConvertDsaPemKey;
1116     impl->base.engineGenerateKeyPairBySpec = EngineGenerateDsaKeyPairBySpec;
1117     impl->base.engineGeneratePubKeyBySpec = EngineGenerateDsaPubKeyBySpec;
1118     impl->base.engineGeneratePriKeyBySpec = EngineGenerateDsaPriKeyBySpec;
1119 
1120     *returnObj = (HcfAsyKeyGeneratorSpi *)impl;
1121     return HCF_SUCCESS;
1122 }
1123