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 "sm2_asy_key_generator_openssl.h"
17 #include "securec.h"
18 #include "ecc_openssl_common.h"
19 #include "ecc_openssl_common_param_spec.h"
20 #include "log.h"
21 #include "memory.h"
22 #include "openssl_adapter.h"
23 #include "utils.h"
24 
25 #define OPENSSL_SM2_256_BITS 256
26 #define OPENSSL_SM2_KEY_GENERATOR_CLASS "OPENSSL.SM2.KEY_GENERATOR_CLASS"
27 #define OPENSSL_SM2_ALGORITHM "SM2"
28 #define OPENSSL_SM2_PUB_KEY_FORMAT "X.509"
29 #define OPENSSL_SM2_PRI_KEY_FORMAT "PKCS#8"
30 static const char *const g_sm2GenerateFieldType = "Fp";
31 
32 typedef struct {
33     HcfAsyKeyGeneratorSpi base;
34 
35     int32_t curveId;
36 } HcfAsyKeyGeneratorSpiOpensslSm2Impl;
37 
CheckSm256CurveId(BIGNUM * p,BIGNUM * b,BIGNUM * x,BIGNUM * y)38 static HcfResult CheckSm256CurveId(BIGNUM *p, BIGNUM *b, BIGNUM *x, BIGNUM *y)
39 {
40     BIGNUM *pStd = NULL;
41     BIGNUM *bStd = NULL;
42     BIGNUM *xStd = NULL;
43     BIGNUM *yStd = NULL;
44     pStd = OpensslBin2Bn(g_sm256CorrectBigP, NID_X9_62_prime256v1_len, NULL);
45     bStd = OpensslBin2Bn(g_sm256CorrectBigB, NID_X9_62_prime256v1_len, NULL);
46     xStd = OpensslBin2Bn(g_sm256CorrectBigGX, NID_X9_62_prime256v1_len, NULL);
47     yStd = OpensslBin2Bn(g_sm256CorrectBigGY, NID_X9_62_prime256v1_len, NULL);
48     if ((pStd == NULL) || (bStd == NULL) || (xStd == NULL) || (yStd == NULL)) {
49         LOGD("[error] EC 256 Curve convert to BN fail");
50         FreeCurveBigNum(pStd, bStd, xStd, yStd);
51         return HCF_ERR_CRYPTO_OPERATION;
52     }
53     if (OpensslBnCmp(p, pStd) == 0 && OpensslBnCmp(b, bStd) == 0 &&
54         OpensslBnCmp(x, xStd) == 0 && OpensslBnCmp(y, yStd) == 0) {
55         FreeCurveBigNum(pStd, bStd, xStd, yStd);
56         return HCF_SUCCESS;
57     }
58     LOGD("[error] EC 256 compare fail");
59     FreeCurveBigNum(pStd, bStd, xStd, yStd);
60     return HCF_INVALID_PARAMS;
61 }
62 
CheckParamsSpecToGetCurveId(const HcfEccCommParamsSpec * ecParams,int32_t * curveId)63 static HcfResult CheckParamsSpecToGetCurveId(const HcfEccCommParamsSpec *ecParams, int32_t *curveId)
64 {
65     BIGNUM *p = NULL;
66     BIGNUM *b = NULL;
67     BIGNUM *x = NULL;
68     BIGNUM *y = NULL;
69     HcfECFieldFp *field = (HcfECFieldFp *)(ecParams->field);
70     if (BigIntegerToBigNum(&(field->p), &p) != HCF_SUCCESS ||
71         BigIntegerToBigNum(&(ecParams->b), &b) != HCF_SUCCESS ||
72         BigIntegerToBigNum(&(ecParams->g.x), &x) != HCF_SUCCESS ||
73         BigIntegerToBigNum(&(ecParams->g.y), &y) != HCF_SUCCESS) {
74         LOGD("[error] BigIntegerToBigNum failed.");
75         FreeCurveBigNum(p, b, x, y);
76         return HCF_ERR_CRYPTO_OPERATION;
77     }
78 
79     int32_t bitLenP = (int32_t)OpensslBnNumBits(p);
80     HcfResult ret = HCF_INVALID_PARAMS;
81     if (bitLenP != OPENSSL_SM2_256_BITS) {
82         LOGE("Find no bit len");
83         FreeCurveBigNum(p, b, x, y);
84         return ret;
85     }
86     ret = CheckSm256CurveId(p, b, x, y);
87     if (ret == HCF_SUCCESS) {
88         *curveId = NID_sm2;
89     }
90     FreeCurveBigNum(p, b, x, y);
91     return ret;
92 }
93 
GenerateSm2KeyWithParamsSpec(const HcfEccCommParamsSpec * ecParams,EC_KEY ** returnKey)94 static HcfResult GenerateSm2KeyWithParamsSpec(const HcfEccCommParamsSpec *ecParams, EC_KEY **returnKey)
95 {
96     if (ecParams == NULL || returnKey == NULL) {
97         LOGE("Invalid input parameters.");
98         return HCF_INVALID_PARAMS;
99     }
100     EC_KEY *ecKey = NULL;
101     int32_t curveId = 0;
102     HcfResult ret = CheckParamsSpecToGetCurveId(ecParams, &curveId);
103     if (ret == HCF_SUCCESS && curveId != 0) {
104         ecKey = OpensslEcKeyNewByCurveName(curveId);
105         LOGD("Generate EC_KEY by curve name");
106         if (ecKey == NULL) {
107             LOGD("[error] New ec key failed.");
108             return HCF_ERR_CRYPTO_OPERATION;
109         }
110     } else {
111         EC_GROUP *group = NULL;
112         ret = GenerateEcGroupWithParamsSpec(ecParams, &group);
113         if (ret != HCF_SUCCESS) {
114             LOGE("GenerateEcGroupWithParamsSpec failed.");
115             return ret;
116         }
117         ecKey = OpensslEcKeyNew();
118         if (ecKey == NULL) {
119             LOGD("[error] OpensslEcKeyNew failed.");
120             OpensslEcGroupFree(group);
121             return HCF_ERR_CRYPTO_OPERATION;
122         }
123         if (OpensslEcKeySetGroup(ecKey, group) != HCF_OPENSSL_SUCCESS) {
124             LOGD("[error] OpensslEcKeySetGroup failed.");
125             OpensslEcGroupFree(group);
126             OpensslEcKeyFree(ecKey);
127             return HCF_ERR_CRYPTO_OPERATION;
128         }
129         OpensslEcGroupFree(group);
130         LOGD("Generate EC_KEY by group spec parmas");
131     }
132     // all exceptions have been returned above.
133     *returnKey = ecKey;
134     return HCF_SUCCESS;
135 }
136 
NewSm2KeyPairWithCommSpec(const HcfEccCommParamsSpec * ecParams,EC_KEY ** returnEckey)137 static HcfResult NewSm2KeyPairWithCommSpec(const HcfEccCommParamsSpec *ecParams, EC_KEY **returnEckey)
138 {
139     if (ecParams == NULL || returnEckey == NULL) {
140         LOGE("Invalid input parameters.");
141         return HCF_INVALID_PARAMS;
142     }
143     EC_KEY *ecKey = NULL;
144     HcfResult ret = GenerateSm2KeyWithParamsSpec(ecParams, &ecKey);
145     if (ret != HCF_SUCCESS) {
146         LOGE("Generate EC key failed");
147         return ret;
148     }
149     if (OpensslEcKeyGenerateKey(ecKey) != HCF_OPENSSL_SUCCESS) {
150         LOGD("[error] OpensslEcKeyGenerateKey failed.");
151         OpensslEcKeyFree(ecKey);
152         return HCF_ERR_CRYPTO_OPERATION;
153     }
154 
155     if (OpensslEcKeyCheckKey(ecKey) <= 0) {
156         LOGD("[error] Check ecKey fail.");
157         OpensslEcKeyFree(ecKey);
158         return HCF_ERR_CRYPTO_OPERATION;
159     }
160     *returnEckey = ecKey;
161     return ret;
162 }
163 
NewSm2PubKeyWithPubSpec(const HcfEccPubKeyParamsSpec * ecParams,EC_KEY ** returnEcKey)164 static HcfResult NewSm2PubKeyWithPubSpec(const HcfEccPubKeyParamsSpec *ecParams, EC_KEY **returnEcKey)
165 {
166     if (ecParams == NULL || returnEcKey == NULL) {
167         LOGE("Invalid input parameters.");
168         return HCF_INVALID_PARAMS;
169     }
170     EC_KEY *ecKey = NULL;
171     HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey);
172     if (ret != HCF_SUCCESS) {
173         LOGE("Generate EC key failed");
174         return ret;
175     }
176     ret = SetEcKey(&(ecParams->pk), NULL, ecKey);
177     if (ret != HCF_SUCCESS) {
178         LOGD("[error] Set public ecKey failed.");
179         OpensslEcKeyFree(ecKey);
180         return HCF_ERR_CRYPTO_OPERATION;
181     }
182 
183     if (OpensslEcKeyCheckKey(ecKey) <= 0) {
184         LOGD("[error] Check ecKey fail.");
185         OpensslEcKeyFree(ecKey);
186         return HCF_ERR_CRYPTO_OPERATION;
187     }
188     *returnEcKey = ecKey;
189     return ret;
190 }
191 
NewSm2PriKeyWithPriSpec(const HcfEccPriKeyParamsSpec * ecParams,EC_KEY ** returnEcKey)192 static HcfResult NewSm2PriKeyWithPriSpec(const HcfEccPriKeyParamsSpec *ecParams, EC_KEY **returnEcKey)
193 {
194     if (ecParams == NULL || returnEcKey == NULL) {
195         LOGE("Invalid input parameters.");
196         return HCF_INVALID_PARAMS;
197     }
198     EC_KEY *ecKey = NULL;
199     HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey);
200     if (ret != HCF_SUCCESS) {
201         LOGE("Generate EC key failed");
202         return ret;
203     }
204     ret = SetEcKey(NULL, &(ecParams->sk), ecKey);
205     if (ret != HCF_SUCCESS) {
206         LOGD("[error] Set private ecKey failed.");
207         OpensslEcKeyFree(ecKey);
208         return HCF_ERR_CRYPTO_OPERATION;
209     }
210 
211     if (OpensslEcKeyCheckKey(ecKey) <= 0) {
212         LOGD("[error] Check ecKey failed.");
213         OpensslEcKeyFree(ecKey);
214         return HCF_ERR_CRYPTO_OPERATION;
215     }
216     *returnEcKey = ecKey;
217     return ret;
218 }
219 
NewSm2KeyWithKeyPairSpec(const HcfEccKeyPairParamsSpec * ecParams,EC_KEY ** returnEcKey,bool needPrivate)220 static HcfResult NewSm2KeyWithKeyPairSpec(const HcfEccKeyPairParamsSpec *ecParams, EC_KEY **returnEcKey,
221     bool needPrivate)
222 {
223     if (ecParams == NULL || returnEcKey == NULL) {
224         LOGE("Invalid input parameters.");
225         return HCF_INVALID_PARAMS;
226     }
227     EC_KEY *ecKey = NULL;
228     HcfResult ret = GenerateSm2KeyWithParamsSpec((HcfEccCommParamsSpec *)ecParams, &ecKey);
229     if (ret != HCF_SUCCESS) {
230         LOGD("[error] Generate EC key failed");
231         return ret;
232     }
233     if (needPrivate) {
234         ret = SetEcKey(&(ecParams->pk), &(ecParams->sk), ecKey);
235     } else {
236         ret = SetEcKey(&(ecParams->pk), NULL, ecKey);
237     }
238     if (ret != HCF_SUCCESS) {
239         LOGD("[error] SetEcKey failed.");
240         OpensslEcKeyFree(ecKey);
241         return HCF_ERR_CRYPTO_OPERATION;
242     }
243 
244     if (OpensslEcKeyCheckKey(ecKey) <= 0) {
245         LOGE("Check ecKey failed.");
246         OpensslEcKeyFree(ecKey);
247         return HCF_ERR_CRYPTO_OPERATION;
248     }
249     *returnEcKey = ecKey;
250     return ret;
251 }
252 
GenKeyPairSm2KeyBySpec(const HcfAsyKeyParamsSpec * params,EC_KEY ** ecKey)253 static HcfResult GenKeyPairSm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey)
254 {
255     HcfResult ret = HCF_INVALID_PARAMS;
256     switch (params->specType) {
257         case HCF_COMMON_PARAMS_SPEC:
258             ret = NewSm2KeyPairWithCommSpec((HcfEccCommParamsSpec *)params, ecKey);
259             break;
260         case HCF_KEY_PAIR_SPEC:
261             ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, true);
262             break;
263         default:
264             LOGE("Invaild input spec to gen key pair.");
265             break;
266     }
267     return ret;
268 }
269 
GenPubKeySm2KeyBySpec(const HcfAsyKeyParamsSpec * params,EC_KEY ** ecKey)270 static HcfResult GenPubKeySm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey)
271 {
272     HcfResult ret = HCF_INVALID_PARAMS;
273     switch (params->specType) {
274         case HCF_PUBLIC_KEY_SPEC:
275             ret = NewSm2PubKeyWithPubSpec((HcfEccPubKeyParamsSpec *)params, ecKey);
276             break;
277         case HCF_KEY_PAIR_SPEC:
278             ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, false);
279             break;
280         default:
281             LOGE("Invaild input spec to gen pub key");
282             break;
283     }
284     return ret;
285 }
286 
GenPriKeySm2KeyBySpec(const HcfAsyKeyParamsSpec * params,EC_KEY ** ecKey)287 static HcfResult GenPriKeySm2KeyBySpec(const HcfAsyKeyParamsSpec *params, EC_KEY **ecKey)
288 {
289     HcfResult ret = HCF_INVALID_PARAMS;
290     switch (params->specType) {
291         case HCF_PRIVATE_KEY_SPEC:
292             ret = NewSm2PriKeyWithPriSpec((HcfEccPriKeyParamsSpec *)params, ecKey);
293             break;
294         case HCF_KEY_PAIR_SPEC:
295             ret = NewSm2KeyWithKeyPairSpec((HcfEccKeyPairParamsSpec *)params, ecKey, true);
296             break;
297         default:
298             LOGE("Invaild input spec to gen pri key");
299             break;
300     }
301     return ret;
302 }
303 
GetSm2KeyPairGeneratorClass(void)304 static const char *GetSm2KeyPairGeneratorClass(void)
305 {
306     return OPENSSL_SM2_KEY_GENERATOR_CLASS;
307 }
308 
GetSm2KeyPairClass(void)309 static const char *GetSm2KeyPairClass(void)
310 {
311     return HCF_OPENSSL_SM2_KEY_PAIR_CLASS;
312 }
313 
GetSm2PubKeyClass(void)314 static const char *GetSm2PubKeyClass(void)
315 {
316     return HCF_OPENSSL_SM2_PUB_KEY_CLASS;
317 }
318 
GetSm2PriKeyClass(void)319 static const char *GetSm2PriKeyClass(void)
320 {
321     return HCF_OPENSSL_SM2_PRI_KEY_CLASS;
322 }
323 
DestroySm2KeyPairGenerator(HcfObjectBase * self)324 static void DestroySm2KeyPairGenerator(HcfObjectBase *self)
325 {
326     if (self == NULL) {
327         LOGE("Class is null.");
328         return;
329     }
330     if (!HcfIsClassMatch(self, GetSm2KeyPairGeneratorClass())) {
331         LOGE("Class not match.");
332         return;
333     }
334     HcfFree(self);
335 }
336 
DestroySm2PubKey(HcfObjectBase * self)337 static void DestroySm2PubKey(HcfObjectBase *self)
338 {
339     if (self == NULL) {
340         LOGE("Class is null.");
341         return;
342     }
343     if (!HcfIsClassMatch(self, GetSm2PubKeyClass())) {
344         LOGE("Class not match.");
345         return;
346     }
347     HcfOpensslSm2PubKey *impl = (HcfOpensslSm2PubKey *)self;
348     OpensslEcKeyFree(impl->ecKey);
349     impl->ecKey = NULL;
350     HcfFree(impl->fieldType);
351     impl->fieldType = NULL;
352     HcfFree(impl);
353 }
354 
DestroySm2PriKey(HcfObjectBase * self)355 static void DestroySm2PriKey(HcfObjectBase *self)
356 {
357     if (self == NULL) {
358         LOGE("Class is null.");
359         return;
360     }
361     if (!HcfIsClassMatch(self, GetSm2PriKeyClass())) {
362         LOGE("Class not match.");
363         return;
364     }
365     HcfOpensslSm2PriKey *impl = (HcfOpensslSm2PriKey *)self;
366     OpensslEcKeyFree(impl->ecKey);
367     impl->ecKey = NULL;
368     HcfFree(impl->fieldType);
369     impl->fieldType = NULL;
370     HcfFree(impl);
371 }
372 
DestroySm2KeyPair(HcfObjectBase * self)373 static void DestroySm2KeyPair(HcfObjectBase *self)
374 {
375     if (self == NULL) {
376         LOGE("Class is null.");
377         return;
378     }
379     if (!HcfIsClassMatch(self, GetSm2KeyPairClass())) {
380         LOGE("Class not match.");
381         return;
382     }
383     HcfOpensslSm2KeyPair *impl = (HcfOpensslSm2KeyPair *)self;
384     if (impl->base.pubKey != NULL) {
385         DestroySm2PubKey((HcfObjectBase *)impl->base.pubKey);
386         impl->base.pubKey = NULL;
387     }
388     if (impl->base.priKey != NULL) {
389         DestroySm2PriKey((HcfObjectBase *)impl->base.priKey);
390         impl->base.priKey = NULL;
391     }
392     HcfFree(impl);
393 }
394 
GetSm2PubKeyAlgorithm(HcfKey * self)395 static const char *GetSm2PubKeyAlgorithm(HcfKey *self)
396 {
397     if (self == NULL) {
398         LOGE("Invalid input parameter.");
399         return NULL;
400     }
401     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PUB_KEY_CLASS)) {
402         LOGE("Invalid SM2 public key class for algorithm");
403         return NULL;
404     }
405     return OPENSSL_SM2_ALGORITHM;
406 }
407 
GetSm2PriKeyAlgorithm(HcfKey * self)408 static const char *GetSm2PriKeyAlgorithm(HcfKey *self)
409 {
410     if (self == NULL) {
411         LOGE("Invalid input parameter.");
412         return NULL;
413     }
414     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PRI_KEY_CLASS)) {
415         LOGE("Invalid SM2 private key class for algorithm");
416         return NULL;
417     }
418     return OPENSSL_SM2_ALGORITHM;
419 }
420 
GetSm2PubKeyFormat(HcfKey * self)421 static const char *GetSm2PubKeyFormat(HcfKey *self)
422 {
423     if (self == NULL) {
424         LOGE("Invalid input parameter.");
425         return NULL;
426     }
427     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PUB_KEY_CLASS)) {
428         LOGE("Invalid SM2 public key class for format");
429         return NULL;
430     }
431     return OPENSSL_SM2_PUB_KEY_FORMAT;
432 }
433 
GetSm2PriKeyFormat(HcfKey * self)434 static const char *GetSm2PriKeyFormat(HcfKey *self)
435 {
436     if (self == NULL) {
437         LOGE("Invalid input parameter.");
438         return NULL;
439     }
440     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PRI_KEY_CLASS)) {
441         LOGE("Invalid SM2 private key class for format");
442         return NULL;
443     }
444     return OPENSSL_SM2_PRI_KEY_FORMAT;
445 }
446 
GetSm2PubKeyEncoded(HcfKey * self,HcfBlob * returnBlob)447 static HcfResult GetSm2PubKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
448 {
449     if ((self == NULL) || (returnBlob == NULL)) {
450         LOGE("Invalid input parameter.");
451         return HCF_INVALID_PARAMS;
452     }
453     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PUB_KEY_CLASS)) {
454         LOGE("Invalid SM2 public key class for encode");
455         return HCF_INVALID_PARAMS;
456     }
457 
458     HcfOpensslSm2PubKey *impl = (HcfOpensslSm2PubKey *)self;
459     if (impl->curveId != 0) {
460         LOGD("Have a curveId");
461         OpensslEcKeySetAsn1Flag(impl->ecKey, OPENSSL_EC_NAMED_CURVE);
462     } else {
463         OpensslEcKeySetAsn1Flag(impl->ecKey, OPENSSL_EC_EXPLICIT_CURVE);
464     }
465 
466     unsigned char *returnData = NULL;
467     int returnDataLen = OpensslI2dEcPubKey(impl->ecKey, &returnData);
468     if (returnDataLen <= 0) {
469         LOGD("[error] Call i2d_EC_PUBKEY fail");
470         HcfPrintOpensslError();
471         return HCF_ERR_CRYPTO_OPERATION;
472     }
473     returnBlob->data = returnData;
474     returnBlob->len = returnDataLen;
475     return HCF_SUCCESS;
476 }
477 
GetSm2PubKeyEncodedPem(HcfKey * self,const char * format,char ** returnString)478 static HcfResult GetSm2PubKeyEncodedPem(HcfKey *self, const char *format, char **returnString)
479 {
480     (void)self;
481     (void)format;
482     (void)returnString;
483     return HCF_INVALID_PARAMS;
484 }
485 
GetSm2PriKeyEncoded(HcfKey * self,HcfBlob * returnBlob)486 static HcfResult GetSm2PriKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
487 {
488     if ((self == NULL) || (returnBlob == NULL)) {
489         LOGE("Invalid input parameter.");
490         return HCF_INVALID_PARAMS;
491     }
492     if (!HcfIsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_SM2_PRI_KEY_CLASS)) {
493         LOGE("Invalid SM2 private key class for encode");
494         return HCF_INVALID_PARAMS;
495     }
496 
497     HcfOpensslSm2PriKey *impl = (HcfOpensslSm2PriKey *)self;
498     if (impl->curveId != 0) {
499         LOGD("Have a curveId");
500         OpensslEcKeySetAsn1Flag(impl->ecKey, OPENSSL_EC_NAMED_CURVE);
501     } else {
502         OpensslEcKeySetAsn1Flag(impl->ecKey, OPENSSL_EC_EXPLICIT_CURVE);
503     }
504     // keep consistence of 3.2
505     OpensslEcKeySetEncFlags(impl->ecKey, EC_PKEY_NO_PUBKEY);
506     // if the convert key has no pubKey, it will generate pub key automatically,
507     // and set the no pubKey flag to ensure the consistency of blob.
508     unsigned char *returnData = NULL;
509     int returnDataLen = OpensslI2dEcPrivateKey(impl->ecKey, &returnData);
510     if (returnDataLen <= 0) {
511         LOGD("[error] Call i2d_ECPrivateKey fail.");
512         HcfPrintOpensslError();
513         return HCF_ERR_CRYPTO_OPERATION;
514     }
515     returnBlob->data = returnData;
516     returnBlob->len = returnDataLen;
517     return HCF_SUCCESS;
518 }
519 
GetSm2PriKeyEncodedPem(HcfKey * self,const char * format,char ** returnString)520 static HcfResult GetSm2PriKeyEncodedPem(HcfKey *self, const char *format, char **returnString)
521 {
522     (void)self;
523     (void)format;
524     (void)returnString;
525     return HCF_INVALID_PARAMS;
526 }
527 
Sm2PriKeyClearMem(HcfPriKey * self)528 static void Sm2PriKeyClearMem(HcfPriKey *self)
529 {
530     if (self == NULL) {
531         LOGE("Class is null.");
532         return;
533     }
534     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSm2PriKeyClass())) {
535         LOGE("Class not match.");
536         return;
537     }
538     HcfOpensslSm2PriKey *impl = (HcfOpensslSm2PriKey *)self;
539     OpensslEcKeyFree(impl->ecKey);
540     impl->ecKey = NULL;
541 }
542 
GetCurveName(const HcfKey * self,bool isPriavte,char ** returnString)543 static HcfResult GetCurveName(const HcfKey *self, bool isPriavte, char **returnString)
544 {
545     int32_t curveId = 0;
546     if (isPriavte) {
547         curveId = ((HcfOpensslSm2PriKey *)self)->curveId;
548     } else {
549         curveId = ((HcfOpensslSm2PubKey *)self)->curveId;
550     }
551 
552     if (curveId != NID_sm2) {
553         LOGD("[error] Invalid curve name.");
554         return HCF_ERR_CRYPTO_OPERATION;
555     }
556 
557     char *curveIdStr = "NID_sm2";
558     size_t len = HcfStrlen(curveIdStr);
559     if (len == 0) {
560         LOGE("CurveIdStr is empty!");
561         return HCF_INVALID_PARAMS;
562     }
563     *returnString = (char *)HcfMalloc(len + 1, 0);
564     if (*returnString == NULL) {
565         LOGE("Allocate returnString memory failed.");
566         return HCF_ERR_MALLOC;
567     }
568     (void)memcpy_s(*returnString, len, curveIdStr, len);
569     return HCF_SUCCESS;
570 }
571 
CheckSm2KeySelf(const HcfKey * self,bool * isPrivate)572 static HcfResult CheckSm2KeySelf(const HcfKey *self, bool *isPrivate)
573 {
574     if (HcfIsClassMatch((HcfObjectBase *)self, GetSm2PubKeyClass())) {
575         *isPrivate = false;
576         return HCF_SUCCESS;
577     } else if (HcfIsClassMatch((HcfObjectBase *)self, GetSm2PriKeyClass())) {
578         if (((HcfOpensslSm2PriKey *)self)->ecKey == NULL) {
579             LOGE("Cannot use priKey after free");
580             return HCF_INVALID_PARAMS;
581         }
582         *isPrivate = true;
583         return HCF_SUCCESS;
584     } else {
585         return HCF_INVALID_PARAMS;
586     }
587 }
588 
GetSm2KeySpecBigInteger(const HcfKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)589 static HcfResult GetSm2KeySpecBigInteger(const HcfKey *self, const AsyKeySpecItem item,
590     HcfBigInteger *returnBigInteger)
591 {
592     if (self == NULL || returnBigInteger == NULL) {
593         LOGE("Invalid input parameter.");
594         return HCF_INVALID_PARAMS;
595     }
596     bool isPrivate = false;
597     HcfResult ret = CheckSm2KeySelf(self, &isPrivate);
598     if (ret != HCF_SUCCESS) {
599         LOGE("Invalid input key");
600         return HCF_INVALID_PARAMS;
601     }
602     const EC_GROUP *group = NULL;
603     if (isPrivate) {
604         group = OpensslEcKeyGet0Group(((HcfOpensslSm2PriKey *)self)->ecKey);
605     } else {
606         group = OpensslEcKeyGet0Group(((HcfOpensslSm2PubKey *)self)->ecKey);
607     }
608     if (group == NULL) {
609         LOGE("Get group failed");
610         return HCF_INVALID_PARAMS;
611     }
612     switch (item) {
613         case ECC_FP_P_BN:
614         case ECC_A_BN:
615         case ECC_B_BN:
616             ret = GetCurveGFp(group, item, returnBigInteger);
617             break;
618         case ECC_G_X_BN:
619         case ECC_G_Y_BN:
620             ret = GetGenerator(group, item, returnBigInteger);
621             break;
622         case ECC_N_BN:
623             ret = GetOrder(group, returnBigInteger);
624             break;
625         case ECC_SK_BN:
626         case ECC_PK_X_BN:
627         case ECC_PK_Y_BN:
628             ret = GetPkSkBigInteger(self, isPrivate, item, returnBigInteger);
629             break;
630         default:
631             LOGE("Invalid ecc key big number spec!");
632             ret = HCF_INVALID_PARAMS;
633             break;
634     }
635     return ret;
636 }
637 
GetSm2KeySpecString(const HcfKey * self,const AsyKeySpecItem item,char ** returnString)638 static HcfResult GetSm2KeySpecString(const HcfKey *self, const AsyKeySpecItem item, char **returnString)
639 {
640     if (self == NULL || returnString == NULL) {
641         LOGE("Invalid input parameter.");
642         return HCF_INVALID_PARAMS;
643     }
644     bool isPrivate = false;
645     HcfResult ret = CheckSm2KeySelf(self, &isPrivate);
646     if (ret != HCF_SUCCESS) {
647         LOGE("Invalid input key");
648         return HCF_INVALID_PARAMS;
649     }
650 
651     switch (item) {
652         case ECC_FIELD_TYPE_STR:
653             ret = GetFieldType(self, isPrivate, returnString);
654             break;
655         case ECC_CURVE_NAME_STR:
656             ret = GetCurveName(self, isPrivate, returnString);
657             break;
658         default:
659             ret = HCF_INVALID_PARAMS;
660             LOGE("Invalid spec of ec string");
661             break;
662     }
663     return ret;
664 }
665 
GetSm2KeySpecInt(const HcfKey * self,const AsyKeySpecItem item,int * returnInt)666 static HcfResult GetSm2KeySpecInt(const HcfKey *self, const AsyKeySpecItem item, int *returnInt)
667 {
668     if (self == NULL || returnInt == NULL) {
669         LOGE("Invalid input parameter.");
670         return HCF_INVALID_PARAMS;
671     }
672     bool isPrivate = false;
673     HcfResult ret = CheckSm2KeySelf(self, &isPrivate);
674     if (ret != HCF_SUCCESS) {
675         LOGE("Invalid input key");
676         return HCF_INVALID_PARAMS;
677     }
678     const EC_GROUP *group = NULL;
679     if (isPrivate) {
680         group = OpensslEcKeyGet0Group(((HcfOpensslSm2PriKey *)self)->ecKey);
681     } else {
682         group = OpensslEcKeyGet0Group(((HcfOpensslSm2PubKey *)self)->ecKey);
683     }
684     if (group == NULL) {
685         LOGE("Get group failed");
686         return HCF_INVALID_PARAMS;
687     }
688     switch (item) {
689         case ECC_H_INT:
690             ret = GetCofactor(group, returnInt);
691             break;
692         case ECC_FIELD_SIZE_INT:
693             ret = GetFieldSize(group, returnInt);
694             break;
695         default:
696             ret = HCF_INVALID_PARAMS;
697             LOGE("Invalid ec key int spec");
698             break;
699     }
700     return ret;
701 }
702 
GetSm2PubKeySpecBigInteger(const HcfPubKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)703 static HcfResult GetSm2PubKeySpecBigInteger(const HcfPubKey *self, const AsyKeySpecItem item,
704     HcfBigInteger *returnBigInteger)
705 {
706     return GetSm2KeySpecBigInteger((HcfKey *)self, item, returnBigInteger);
707 }
708 
GetSm2PriKeySpecBigInteger(const HcfPriKey * self,const AsyKeySpecItem item,HcfBigInteger * returnBigInteger)709 static HcfResult GetSm2PriKeySpecBigInteger(const HcfPriKey *self, const AsyKeySpecItem item,
710     HcfBigInteger *returnBigInteger)
711 {
712     return GetSm2KeySpecBigInteger((HcfKey *)self, item, returnBigInteger);
713 }
714 
GetSm2PubKeySpecString(const HcfPubKey * self,const AsyKeySpecItem item,char ** returnString)715 static HcfResult GetSm2PubKeySpecString(const HcfPubKey *self, const AsyKeySpecItem item, char **returnString)
716 {
717     return GetSm2KeySpecString((HcfKey *)self, item, returnString);
718 }
719 
GetSm2PriKeySpecString(const HcfPriKey * self,const AsyKeySpecItem item,char ** returnString)720 static HcfResult GetSm2PriKeySpecString(const HcfPriKey *self, const AsyKeySpecItem item, char **returnString)
721 {
722     return GetSm2KeySpecString((HcfKey *)self, item, returnString);
723 }
724 
GetSm2PubKeySpecInt(const HcfPubKey * self,const AsyKeySpecItem item,int * returnInt)725 static HcfResult GetSm2PubKeySpecInt(const HcfPubKey *self, const AsyKeySpecItem item, int *returnInt)
726 {
727     return GetSm2KeySpecInt((HcfKey *)self, item, returnInt);
728 }
729 
GetSm2PriKeySpecInt(const HcfPriKey * self,const AsyKeySpecItem item,int * returnInt)730 static HcfResult GetSm2PriKeySpecInt(const HcfPriKey *self, const AsyKeySpecItem item, int *returnInt)
731 {
732     return GetSm2KeySpecInt((HcfKey *)self, item, returnInt);
733 }
734 
GetSm2PubKeyEncodedDer(const HcfPubKey * self,const char * format,HcfBlob * returnBlob)735 static HcfResult GetSm2PubKeyEncodedDer(const HcfPubKey *self, const char *format, HcfBlob *returnBlob)
736 {
737     (void)self;
738     (void)format;
739     (void)returnBlob;
740     return HCF_INVALID_PARAMS;
741 }
742 
PackSm2PubKey(int32_t curveId,EC_KEY * ecKey,const char * fieldType,HcfOpensslSm2PubKey ** returnObj)743 static HcfResult PackSm2PubKey(int32_t curveId, EC_KEY *ecKey, const char *fieldType,
744     HcfOpensslSm2PubKey **returnObj)
745 {
746     HcfOpensslSm2PubKey *returnPubKey = (HcfOpensslSm2PubKey *)HcfMalloc(sizeof(HcfOpensslSm2PubKey), 0);
747     if (returnPubKey == NULL) {
748         LOGE("Failed to allocate returnPubKey memory!");
749         return HCF_ERR_MALLOC;
750     }
751 
752     char *tmpFieldType = NULL;
753     if (fieldType != NULL) {
754         size_t len = HcfStrlen(fieldType);
755         if (len == 0) {
756             LOGE("FieldType is empty!");
757             HcfFree(returnPubKey);
758             return HCF_INVALID_PARAMS;
759         }
760         tmpFieldType = (char *)HcfMalloc(len + 1, 0);
761         if (tmpFieldType == NULL) {
762             LOGE("Allocate tmpFieldType memory failed.");
763             HcfFree(returnPubKey);
764             return HCF_ERR_MALLOC;
765         }
766         (void)memcpy_s(tmpFieldType, len, fieldType, len);
767     }
768     returnPubKey->base.base.base.destroy = DestroySm2PubKey;
769     returnPubKey->base.base.base.getClass = GetSm2PubKeyClass;
770     returnPubKey->base.base.getAlgorithm = GetSm2PubKeyAlgorithm;
771     returnPubKey->base.base.getEncoded = GetSm2PubKeyEncoded;
772     returnPubKey->base.base.getEncodedPem = GetSm2PubKeyEncodedPem;
773     returnPubKey->base.base.getFormat = GetSm2PubKeyFormat;
774     returnPubKey->base.getAsyKeySpecBigInteger = GetSm2PubKeySpecBigInteger;
775     returnPubKey->base.getAsyKeySpecString = GetSm2PubKeySpecString;
776     returnPubKey->base.getAsyKeySpecInt = GetSm2PubKeySpecInt;
777     returnPubKey->base.getEncodedDer = GetSm2PubKeyEncodedDer;
778     returnPubKey->curveId = curveId;
779     returnPubKey->ecKey = ecKey;
780     returnPubKey->fieldType = tmpFieldType;
781 
782     *returnObj = returnPubKey;
783     return HCF_SUCCESS;
784 }
785 
GetSm2PriKeyEncodedDer(const HcfPriKey * self,const char * format,HcfBlob * returnBlob)786 static HcfResult GetSm2PriKeyEncodedDer(const HcfPriKey *self, const char *format, HcfBlob *returnBlob)
787 {
788     (void)self;
789     (void)format;
790     (void)returnBlob;
791     return HCF_INVALID_PARAMS;
792 }
793 
PackSm2PriKey(int32_t curveId,EC_KEY * ecKey,const char * fieldType,HcfOpensslSm2PriKey ** returnObj)794 static HcfResult PackSm2PriKey(int32_t curveId, EC_KEY *ecKey, const char *fieldType,
795     HcfOpensslSm2PriKey **returnObj)
796 {
797     HcfOpensslSm2PriKey *returnPriKey = (HcfOpensslSm2PriKey *)HcfMalloc(sizeof(HcfOpensslSm2PriKey), 0);
798     if (returnPriKey == NULL) {
799         LOGE("Failed to allocate returnPriKey memory!");
800         return HCF_ERR_MALLOC;
801     }
802 
803     char *tmpFieldType = NULL;
804     if (fieldType != NULL) {
805         size_t len = HcfStrlen(fieldType);
806         if (len == 0) {
807             LOGE("FieldType is empty!");
808             HcfFree(returnPriKey);
809             return HCF_INVALID_PARAMS;
810         }
811         tmpFieldType = (char *)HcfMalloc(len + 1, 0);
812         if (tmpFieldType == NULL) {
813             LOGE("Allocate tmpFieldType memory failed.");
814             HcfFree(returnPriKey);
815             return HCF_ERR_MALLOC;
816         }
817         (void)memcpy_s(tmpFieldType, len, fieldType, len);
818     }
819     returnPriKey->base.base.base.destroy = DestroySm2PriKey;
820     returnPriKey->base.base.base.getClass = GetSm2PriKeyClass;
821     returnPriKey->base.base.getAlgorithm = GetSm2PriKeyAlgorithm;
822     returnPriKey->base.base.getEncoded = GetSm2PriKeyEncoded;
823     returnPriKey->base.base.getEncodedPem = GetSm2PriKeyEncodedPem;
824     returnPriKey->base.base.getFormat = GetSm2PriKeyFormat;
825     returnPriKey->base.getAsyKeySpecBigInteger = GetSm2PriKeySpecBigInteger;
826     returnPriKey->base.getAsyKeySpecString = GetSm2PriKeySpecString;
827     returnPriKey->base.getAsyKeySpecInt = GetSm2PriKeySpecInt;
828     returnPriKey->base.clearMem = Sm2PriKeyClearMem;
829     returnPriKey->base.getEncodedDer = GetSm2PriKeyEncodedDer;
830     returnPriKey->curveId = curveId;
831     returnPriKey->ecKey = ecKey;
832     returnPriKey->fieldType = tmpFieldType;
833 
834     *returnObj = returnPriKey;
835     return HCF_SUCCESS;
836 }
837 
PackSm2KeyPair(HcfOpensslSm2PubKey * pubKey,HcfOpensslSm2PriKey * priKey,HcfOpensslSm2KeyPair ** returnObj)838 static HcfResult PackSm2KeyPair(HcfOpensslSm2PubKey *pubKey, HcfOpensslSm2PriKey *priKey,
839     HcfOpensslSm2KeyPair **returnObj)
840 {
841     HcfOpensslSm2KeyPair *returnKeyPair = (HcfOpensslSm2KeyPair *)HcfMalloc(sizeof(HcfOpensslSm2KeyPair), 0);
842     if (returnKeyPair == NULL) {
843         LOGE("Failed to allocate returnKeyPair memory!");
844         return HCF_ERR_MALLOC;
845     }
846     returnKeyPair->base.base.getClass = GetSm2KeyPairClass;
847     returnKeyPair->base.base.destroy = DestroySm2KeyPair;
848     returnKeyPair->base.pubKey = (HcfPubKey *)pubKey;
849     returnKeyPair->base.priKey = (HcfPriKey *)priKey;
850 
851     *returnObj = returnKeyPair;
852     return HCF_SUCCESS;
853 }
854 
ConvertEcPubKey(int32_t curveId,HcfBlob * pubKeyBlob,HcfOpensslSm2PubKey ** returnPubKey)855 static HcfResult ConvertEcPubKey(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpensslSm2PubKey **returnPubKey)
856 {
857     const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data);
858     EC_KEY *ecKey = OpensslD2iEcPubKey(NULL, &tmpData, pubKeyBlob->len);
859     if (ecKey == NULL) {
860         LOGD("[error] Call d2i_EC_PUBKEY fail.");
861         HcfPrintOpensslError();
862         return HCF_ERR_CRYPTO_OPERATION;
863     }
864     HcfResult ret = PackSm2PubKey(curveId, ecKey, g_sm2GenerateFieldType, returnPubKey);
865     if (ret != HCF_SUCCESS) {
866         LOGE("CreateSm2PubKey failed.");
867         OpensslEcKeyFree(ecKey);
868         return ret;
869     }
870     return HCF_SUCCESS;
871 }
872 
ConvertEcPriKey(int32_t curveId,HcfBlob * priKeyBlob,HcfOpensslSm2PriKey ** returnPriKey)873 static HcfResult ConvertEcPriKey(int32_t curveId, HcfBlob *priKeyBlob, HcfOpensslSm2PriKey **returnPriKey)
874 {
875     const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data);
876     EC_KEY *ecKey = OpensslD2iEcPrivateKey(NULL, &tmpData, priKeyBlob->len);
877     if (ecKey == NULL) {
878         LOGD("[error] Call d2i_ECPrivateKey fail");
879         HcfPrintOpensslError();
880         return HCF_ERR_CRYPTO_OPERATION;
881     }
882     HcfResult ret = PackSm2PriKey(curveId, ecKey, g_sm2GenerateFieldType, returnPriKey);
883     if (ret != HCF_SUCCESS) {
884         LOGE("CreateSm2PriKey failed.");
885         OpensslEcKeyFree(ecKey);
886         return ret;
887     }
888     return HCF_SUCCESS;
889 }
890 
EngineConvertSm2Key(HcfAsyKeyGeneratorSpi * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)891 static HcfResult EngineConvertSm2Key(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
892     HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
893 {
894     (void)params;
895     if ((self == NULL) || (returnKeyPair == NULL)) {
896         LOGE("Invalid input parameter.");
897         return HCF_INVALID_PARAMS;
898     }
899     if (!HcfIsClassMatch((HcfObjectBase *)self, self->base.getClass())) {
900         LOGE("Class not match.");
901         return HCF_INVALID_PARAMS;
902     }
903     bool pubKeyValid = HcfIsBlobValid(pubKeyBlob);
904     bool priKeyValid = HcfIsBlobValid(priKeyBlob);
905     if ((!pubKeyValid) && (!priKeyValid)) {
906         LOGE("The private key and public key cannot both be NULL.");
907         return HCF_INVALID_PARAMS;
908     }
909 
910     HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self;
911     HcfResult ret = HCF_SUCCESS;
912     HcfOpensslSm2PubKey *pubKey = NULL;
913     HcfOpensslSm2PriKey *priKey = NULL;
914     HcfOpensslSm2KeyPair *keyPair = NULL;
915     do {
916         if (pubKeyValid) {
917             ret = ConvertEcPubKey(impl->curveId, pubKeyBlob, &pubKey);
918             if (ret != HCF_SUCCESS) {
919                 LOGD("[error] Convert ec pubKey failed.");
920                 break;
921             }
922         }
923         if (priKeyValid) {
924             ret = ConvertEcPriKey(impl->curveId, priKeyBlob, &priKey);
925             if (ret != HCF_SUCCESS) {
926                 LOGD("[error] Convert ec priKey failed.");
927                 break;
928             }
929         }
930         ret = PackSm2KeyPair(pubKey, priKey, &keyPair);
931     } while (0);
932     if (ret != HCF_SUCCESS) {
933         LOGD("[error] Convert sm2 keyPair failed.");
934         HcfObjDestroy(pubKey);
935         HcfObjDestroy(priKey);
936         return ret;
937     }
938 
939     *returnKeyPair = (HcfKeyPair *)keyPair;
940     return HCF_SUCCESS;
941 }
942 
PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl * impl,const char * fieldType,EC_KEY * ecKey,HcfPubKey ** returnObj)943 static HcfResult PackAndAssignPubKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType,
944     EC_KEY *ecKey, HcfPubKey **returnObj)
945 {
946     HcfOpensslSm2PubKey *pubKey = NULL;
947     HcfResult ret = PackSm2PubKey(impl->curveId, ecKey, fieldType, &pubKey);
948     if (ret != HCF_SUCCESS) {
949         LOGD("[error] Create sm2 pubKey failed.");
950         return ret;
951     }
952     *returnObj = (HcfPubKey *)pubKey;
953     return HCF_SUCCESS;
954 }
955 
PackAndAssignPriKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl * impl,const char * fieldType,EC_KEY * ecKey,HcfPriKey ** returnObj)956 static HcfResult PackAndAssignPriKey(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType,
957     EC_KEY *ecKey, HcfPriKey **returnObj)
958 {
959     HcfOpensslSm2PriKey *priKey = NULL;
960     HcfResult ret = PackSm2PriKey(impl->curveId, ecKey, fieldType, &priKey);
961     if (ret != HCF_SUCCESS) {
962         LOGD("[error] Create sm2 priKey failed.");
963         return ret;
964     }
965     *returnObj = (HcfPriKey *)priKey;
966     return HCF_SUCCESS;
967 }
968 
CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Impl * impl,const char * fieldType,EC_KEY * ecKey,HcfKeyPair ** returnObj)969 static HcfResult CreateAndAssignKeyPair(const HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl, const char *fieldType,
970     EC_KEY *ecKey, HcfKeyPair **returnObj)
971 {
972     EC_KEY *ecPriKey = EC_KEY_dup(ecKey);
973     if (ecPriKey == NULL) {
974         LOGD("[error] Dup ecKey fail.");
975         return HCF_ERR_CRYPTO_OPERATION;
976     }
977     HcfOpensslSm2PriKey *priKey = NULL;
978     HcfResult ret = PackSm2PriKey(impl->curveId, ecPriKey, fieldType, &priKey);
979     if (ret != HCF_SUCCESS) {
980         LOGD("[error] Create sm2 priKey failed.");
981         OpensslEcKeyFree(ecPriKey);
982         return ret;
983     }
984     HcfOpensslSm2PubKey *pubKey = NULL;
985     EC_KEY *ecPubKey = EC_KEY_dup(ecKey);
986     if (ecPubKey == NULL) {
987         LOGD("[error] Dup ecKey fail.");
988         HcfObjDestroy(priKey);
989         return HCF_ERR_CRYPTO_OPERATION;
990     }
991     ret = PackSm2PubKey(impl->curveId, ecPubKey, fieldType, &pubKey);
992     if (ret != HCF_SUCCESS) {
993         LOGD("[error] Create sm2 pubKey failed.");
994         HcfObjDestroy(priKey);
995         OpensslEcKeyFree(ecPubKey);
996         return ret;
997     }
998 
999     HcfOpensslSm2KeyPair *returnKeyPair = NULL;
1000     ret = PackSm2KeyPair(pubKey, priKey, &returnKeyPair);
1001     if (ret != HCF_SUCCESS) {
1002         LOGE("Create sm2 keyPair failed.");
1003         HcfObjDestroy(pubKey);
1004         HcfObjDestroy(priKey);
1005     }
1006     *returnObj = (HcfKeyPair *)returnKeyPair;
1007     return ret;
1008 }
1009 
EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi * self,HcfKeyPair ** returnObj)1010 static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnObj)
1011 {
1012     if ((self == NULL) || (returnObj == NULL)) {
1013         LOGE("Invalid input parameter.");
1014         return HCF_INVALID_PARAMS;
1015     }
1016     if (!HcfIsClassMatch((HcfObjectBase *)self, self->base.getClass())) {
1017         LOGE("Class not match.");
1018         return HCF_INVALID_PARAMS;
1019     }
1020 
1021     HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self;
1022     EC_KEY *ecKey = NULL;
1023     HcfResult ret = NewEcKeyPair(impl->curveId, &ecKey);
1024     if (ret == HCF_SUCCESS) {
1025         ret = CreateAndAssignKeyPair(impl, g_sm2GenerateFieldType, ecKey, returnObj);
1026         if (ret != HCF_SUCCESS) {
1027             LOGD("[error] CreateAndAssignKeyPair failed.");
1028         }
1029         OpensslEcKeyFree(ecKey);
1030     }
1031     return ret;
1032 }
1033 
EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * params,HcfKeyPair ** returnKeyPair)1034 static HcfResult EngineGenerateKeyPairBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params,
1035     HcfKeyPair **returnKeyPair)
1036 {
1037     if ((self == NULL) || (returnKeyPair == NULL) || (params == NULL) ||
1038         (((HcfEccCommParamsSpec *)params)->field == NULL)) {
1039         LOGE("Invalid input parameter.");
1040         return HCF_INVALID_PARAMS;
1041     }
1042     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) {
1043         LOGE("Class not match.");
1044         return HCF_INVALID_PARAMS;
1045     }
1046 
1047     HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self;
1048     EC_KEY *ecKey = NULL;
1049     HcfResult ret = GenKeyPairSm2KeyBySpec(params, &ecKey);
1050     if (ret != HCF_SUCCESS) {
1051         LOGD("[error] Gen ec key pair with spec failed.");
1052         return ret;
1053     }
1054 
1055     // curveId == 0 means no curve to match.
1056     int32_t curveId = (int32_t)OpensslEcGroupGetCurveName(OpensslEcKeyGet0Group(ecKey));
1057     if (curveId != 0) {
1058         impl->curveId = curveId;
1059     }
1060     // deep copy of ecKey, free ecKey whether it succeed or failed.
1061     ret = CreateAndAssignKeyPair(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnKeyPair);
1062     OpensslEcKeyFree(ecKey);
1063     if (ret != HCF_SUCCESS) {
1064         LOGD("[error] CreateAndAssignKeyPair failed.");
1065         return ret;
1066     }
1067     return HCF_SUCCESS;
1068 }
1069 
EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * params,HcfPubKey ** returnPubKey)1070 static HcfResult EngineGeneratePubKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params,
1071     HcfPubKey **returnPubKey)
1072 {
1073     if ((self == NULL) || (returnPubKey == NULL) || (params == NULL) ||
1074         (((HcfEccCommParamsSpec *)params)->field == NULL)) {
1075         LOGE("Invalid input parameter.");
1076         return HCF_INVALID_PARAMS;
1077     }
1078     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) {
1079         LOGE("Class not match.");
1080         return HCF_INVALID_PARAMS;
1081     }
1082 
1083     HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self;
1084     EC_KEY *ecKey = NULL;
1085     HcfResult ret = GenPubKeySm2KeyBySpec(params, &ecKey);
1086     if (ret != HCF_SUCCESS) {
1087         LOGD("[error] Gen ec pubKey with spec failed.");
1088         return ret;
1089     }
1090     int32_t curveId = (int32_t)OpensslEcGroupGetCurveName(OpensslEcKeyGet0Group(ecKey));
1091     if (curveId != 0) {
1092         impl->curveId = curveId;
1093     }
1094     ret = PackAndAssignPubKey(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnPubKey);
1095     if (ret != HCF_SUCCESS) {
1096         LOGD("[error] PackAndAssignPubKey failed.");
1097         OpensslEcKeyFree(ecKey);
1098         return ret;
1099     }
1100     return HCF_SUCCESS;
1101 }
1102 
EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi * self,const HcfAsyKeyParamsSpec * params,HcfPriKey ** returnPriKey)1103 static HcfResult EngineGeneratePriKeyBySpec(const HcfAsyKeyGeneratorSpi *self, const HcfAsyKeyParamsSpec *params,
1104     HcfPriKey **returnPriKey)
1105 {
1106     if ((self == NULL) || (returnPriKey == NULL) || (params == NULL) ||
1107         (((HcfEccCommParamsSpec *)params)->field == NULL)) {
1108         LOGE("Invalid input parameter.");
1109         return HCF_INVALID_PARAMS;
1110     }
1111     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSm2KeyPairGeneratorClass())) {
1112         LOGE("Class not match.");
1113         return HCF_INVALID_PARAMS;
1114     }
1115 
1116     HcfAsyKeyGeneratorSpiOpensslSm2Impl *impl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)self;
1117     EC_KEY *ecKey = NULL;
1118     HcfResult ret = GenPriKeySm2KeyBySpec(params, &ecKey);
1119     if (ret != HCF_SUCCESS) {
1120         LOGD("[error] Gen ec priKey with spec failed.");
1121         return ret;
1122     }
1123 
1124     int32_t curveId = (int32_t)OpensslEcGroupGetCurveName(OpensslEcKeyGet0Group(ecKey));
1125     if (curveId != 0) {
1126         impl->curveId = curveId;
1127     }
1128 
1129     ret = PackAndAssignPriKey(impl, ((HcfEccCommParamsSpec *)params)->field->fieldType, ecKey, returnPriKey);
1130     if (ret != HCF_SUCCESS) {
1131         LOGD("[error] PackAndAssignPriKey failed.");
1132         OpensslEcKeyFree(ecKey);
1133         return ret;
1134     }
1135     return HCF_SUCCESS;
1136 }
1137 
HcfAsyKeyGeneratorSpiSm2Create(HcfAsyKeyGenParams * params,HcfAsyKeyGeneratorSpi ** returnObj)1138 HcfResult HcfAsyKeyGeneratorSpiSm2Create(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj)
1139 {
1140     if (params == NULL || returnObj == NULL) {
1141         LOGE("Invalid input parameter.");
1142         return HCF_INVALID_PARAMS;
1143     }
1144     int32_t curveId = 0;
1145     if (params->bits != 0) {
1146         if (GetOpensslCurveId(params->bits, &curveId) != HCF_SUCCESS) {
1147             LOGE("Get curve id failed.");
1148             return HCF_INVALID_PARAMS;
1149         }
1150     }
1151 
1152     HcfAsyKeyGeneratorSpiOpensslSm2Impl *returnImpl = (HcfAsyKeyGeneratorSpiOpensslSm2Impl *)HcfMalloc(
1153         sizeof(HcfAsyKeyGeneratorSpiOpensslSm2Impl), 0);
1154     if (returnImpl == NULL) {
1155         LOGE("Failed to allocate returnImpl memroy!");
1156         return HCF_ERR_MALLOC;
1157     }
1158     returnImpl->base.base.getClass = GetSm2KeyPairGeneratorClass;
1159     returnImpl->base.base.destroy = DestroySm2KeyPairGenerator;
1160     returnImpl->base.engineConvertKey = EngineConvertSm2Key;
1161     returnImpl->base.engineGenerateKeyPair = EngineGenerateKeyPair;
1162     returnImpl->base.engineGenerateKeyPairBySpec = EngineGenerateKeyPairBySpec;
1163     returnImpl->base.engineGeneratePubKeyBySpec = EngineGeneratePubKeyBySpec;
1164     returnImpl->base.engineGeneratePriKeyBySpec = EngineGeneratePriKeyBySpec;
1165     returnImpl->curveId = curveId;
1166 
1167     *returnObj = (HcfAsyKeyGeneratorSpi *)returnImpl;
1168     return HCF_SUCCESS;
1169 }
1170