1 /*
2  * Copyright (C) 2022-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 "signature.h"
17 
18 #include <securec.h>
19 
20 #include "config.h"
21 #include "dsa_openssl.h"
22 #include "ecdsa_openssl.h"
23 #include "log.h"
24 #include "memory.h"
25 #include "params_parser.h"
26 #include "signature_spi.h"
27 #include "signature_rsa_openssl.h"
28 #include "sm2_openssl.h"
29 #include "ed25519_openssl.h"
30 #include "utils.h"
31 
32 typedef HcfResult (*HcfSignSpiCreateFunc)(HcfSignatureParams *, HcfSignSpi **);
33 typedef HcfResult (*HcfVerifySpiCreateFunc)(HcfSignatureParams *, HcfVerifySpi **);
34 
35 typedef struct {
36     HcfSign base;
37 
38     HcfSignSpi *spiObj;
39 
40     char algoName[HCF_MAX_ALGO_NAME_LEN];
41 } HcfSignImpl;
42 
43 typedef struct {
44     HcfVerify base;
45 
46     HcfVerifySpi *spiObj;
47 
48     char algoName[HCF_MAX_ALGO_NAME_LEN];
49 } HcfVerifyImpl;
50 
51 typedef struct {
52     HcfAlgValue algo;
53 
54     HcfSignSpiCreateFunc createFunc;
55 } HcfSignGenAbility;
56 
57 typedef struct {
58     HcfAlgValue algo;
59 
60     HcfVerifySpiCreateFunc createFunc;
61 } HcfVerifyGenAbility;
62 
63 static const HcfSignGenAbility SIGN_GEN_ABILITY_SET[] = {
64     { HCF_ALG_ECC, HcfSignSpiEcdsaCreate },
65     { HCF_ALG_RSA, HcfSignSpiRsaCreate },
66     { HCF_ALG_DSA, HcfSignSpiDsaCreate },
67     { HCF_ALG_SM2, HcfSignSpiSm2Create },
68     { HCF_ALG_ECC_BRAINPOOL, HcfSignSpiEcdsaCreate },
69     { HCF_ALG_ED25519, HcfSignSpiEd25519Create },
70 };
71 
72 static const HcfVerifyGenAbility VERIFY_GEN_ABILITY_SET[] = {
73     { HCF_ALG_ECC, HcfVerifySpiEcdsaCreate },
74     { HCF_ALG_RSA, HcfVerifySpiRsaCreate },
75     { HCF_ALG_DSA, HcfVerifySpiDsaCreate },
76     { HCF_ALG_SM2, HcfVerifySpiSm2Create },
77     { HCF_ALG_ECC_BRAINPOOL, HcfVerifySpiEcdsaCreate },
78     { HCF_ALG_ED25519, HcfVerifySpiEd25519Create },
79 };
80 
FindSignAbility(HcfSignatureParams *params)81 static HcfSignSpiCreateFunc FindSignAbility(HcfSignatureParams *params)
82 {
83     if (params->operation == HCF_ALG_ONLY_SIGN && params->algo != HCF_ALG_RSA) {
84         LOGE("Algo not support in OnlySign! [Algo]: %d", params->algo);
85         return NULL;
86     }
87 
88     for (uint32_t i = 0; i < sizeof(SIGN_GEN_ABILITY_SET) / sizeof(SIGN_GEN_ABILITY_SET[0]); i++) {
89         if (SIGN_GEN_ABILITY_SET[i].algo == params->algo) {
90             return SIGN_GEN_ABILITY_SET[i].createFunc;
91         }
92     }
93     LOGE("Algo not support! [Algo]: %d", params->algo);
94     return NULL;
95 }
96 
FindVerifyAbility(HcfSignatureParams *params)97 static HcfVerifySpiCreateFunc FindVerifyAbility(HcfSignatureParams *params)
98 {
99     if (params->operation == HCF_ALG_VERIFY_RECOVER && params->algo != HCF_ALG_RSA) {
100         LOGE("Failed to check recover params!");
101         return NULL;
102     }
103 
104     for (uint32_t i = 0; i < sizeof(VERIFY_GEN_ABILITY_SET) / sizeof(VERIFY_GEN_ABILITY_SET[0]); i++) {
105         if (VERIFY_GEN_ABILITY_SET[i].algo == params->algo) {
106             return VERIFY_GEN_ABILITY_SET[i].createFunc;
107         }
108     }
109     LOGE("Algo not support! [Algo]: %d", params->algo);
110     return NULL;
111 }
112 
SetKeyTypeDefault(HcfAlgParaValue value, HcfSignatureParams *paramsObj)113 static void SetKeyTypeDefault(HcfAlgParaValue value,  HcfSignatureParams *paramsObj)
114 {
115     switch (value) {
116         case HCF_ALG_ECC_DEFAULT:
117             paramsObj->algo = HCF_ALG_ECC;
118             break;
119         case HCF_ALG_RSA_DEFAULT:
120             paramsObj->algo = HCF_ALG_RSA;
121             break;
122         case HCF_ALG_DSA_DEFAULT:
123             paramsObj->algo = HCF_ALG_DSA;
124             break;
125         case HCF_ALG_SM2_DEFAULT:
126             paramsObj->algo = HCF_ALG_SM2;
127             break;
128         case HCF_ALG_ECC_BRAINPOOL_DEFAULT:
129             paramsObj->algo = HCF_ALG_ECC_BRAINPOOL;
130             break;
131         default:
132             LOGE("Invalid algo %u.", value);
133             break;
134     }
135 }
136 
SetKeyType(HcfAlgParaValue value, HcfSignatureParams *paramsObj)137 static void SetKeyType(HcfAlgParaValue value, HcfSignatureParams *paramsObj)
138 {
139     switch (value) {
140         case HCF_ALG_ECC_224:
141         case HCF_ALG_ECC_256:
142         case HCF_ALG_ECC_384:
143         case HCF_ALG_ECC_521:
144             paramsObj->algo = HCF_ALG_ECC;
145             break;
146         case HCF_ALG_ECC_BP160R1:
147         case HCF_ALG_ECC_BP160T1:
148         case HCF_ALG_ECC_BP192R1:
149         case HCF_ALG_ECC_BP192T1:
150         case HCF_ALG_ECC_BP224R1:
151         case HCF_ALG_ECC_BP224T1:
152         case HCF_ALG_ECC_BP256R1:
153         case HCF_ALG_ECC_BP256T1:
154         case HCF_ALG_ECC_BP320R1:
155         case HCF_ALG_ECC_BP320T1:
156         case HCF_ALG_ECC_BP384R1:
157         case HCF_ALG_ECC_BP384T1:
158         case HCF_ALG_ECC_BP512R1:
159         case HCF_ALG_ECC_BP512T1:
160             paramsObj->algo = HCF_ALG_ECC_BRAINPOOL;
161             break;
162         case HCF_OPENSSL_RSA_512:
163         case HCF_OPENSSL_RSA_768:
164         case HCF_OPENSSL_RSA_1024:
165         case HCF_OPENSSL_RSA_2048:
166         case HCF_OPENSSL_RSA_3072:
167         case HCF_OPENSSL_RSA_4096:
168         case HCF_OPENSSL_RSA_8192:
169             paramsObj->algo = HCF_ALG_RSA;
170             break;
171         case HCF_ALG_DSA_1024:
172         case HCF_ALG_DSA_2048:
173         case HCF_ALG_DSA_3072:
174             paramsObj->algo = HCF_ALG_DSA;
175             break;
176         case HCF_ALG_SM2_256:
177             paramsObj->algo = HCF_ALG_SM2;
178             break;
179         case HCF_ALG_ED25519_256:
180             paramsObj->algo = HCF_ALG_ED25519;
181             break;
182         default:
183             LOGE("there is not matched algorithm.");
184             break;
185     }
186 }
187 
ParseSignatureParams(const HcfParaConfig *config, void *params)188 static HcfResult ParseSignatureParams(const HcfParaConfig *config, void *params)
189 {
190     if (config == NULL || params == NULL) {
191         LOGE("Invalid signature params");
192         return HCF_INVALID_PARAMS;
193     }
194     HcfResult ret = HCF_SUCCESS;
195     HcfSignatureParams *paramsObj = (HcfSignatureParams *)params;
196     LOGD("Set Parameter: %s", config->tag);
197     switch (config->paraType) {
198         case HCF_ALG_TYPE:
199             SetKeyTypeDefault(config->paraValue, paramsObj);
200             break;
201         case HCF_ALG_KEY_TYPE:
202             SetKeyType(config->paraValue, paramsObj);
203             break;
204         case HCF_ALG_DIGEST:
205             paramsObj->md = config->paraValue;
206             break;
207         case HCF_ALG_PADDING_TYPE:
208             paramsObj->padding = config->paraValue;
209             break;
210         case HCF_ALG_MGF1_DIGEST:
211             paramsObj->mgf1md = config->paraValue;
212             break;
213         case HCF_ALG_SIGN_TYPE:
214             paramsObj->operation = config->paraValue;
215             break;
216         case HCF_ALG_VERIFY_TYPE:
217             paramsObj->operation = config->paraValue;
218             break;
219         default:
220             ret = HCF_INVALID_PARAMS;
221             break;
222     }
223     return ret;
224 }
225 
GetSignClass(void)226 static const char *GetSignClass(void)
227 {
228     return "HcfSign";
229 }
230 
GetVerifyClass(void)231 static const char *GetVerifyClass(void)
232 {
233     return "HcfVerify";
234 }
235 
GetSignAlgoName(HcfSign *self)236 static const char *GetSignAlgoName(HcfSign *self)
237 {
238     if (self == NULL) {
239         LOGE("The input self ptr is NULL!");
240         return NULL;
241     }
242     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
243         return NULL;
244     }
245     return ((HcfSignImpl *)self)->algoName;
246 }
247 
GetVerifyAlgoName(HcfVerify *self)248 static const char *GetVerifyAlgoName(HcfVerify *self)
249 {
250     if (self == NULL) {
251         LOGE("The input self ptr is NULL!");
252         return NULL;
253     }
254     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
255         return NULL;
256     }
257     return ((HcfVerifyImpl *)self)->algoName;
258 }
259 
DestroySign(HcfObjectBase *self)260 static void DestroySign(HcfObjectBase *self)
261 {
262     if (self == NULL) {
263         return;
264     }
265     if (!HcfIsClassMatch(self, GetSignClass())) {
266         LOGE("Class not match.");
267         return;
268     }
269     HcfSignImpl *impl = (HcfSignImpl *)self;
270     HcfObjDestroy(impl->spiObj);
271     impl->spiObj = NULL;
272     HcfFree(impl);
273 }
274 
DestroyVerify(HcfObjectBase *self)275 static void DestroyVerify(HcfObjectBase *self)
276 {
277     if (self == NULL) {
278         return;
279     }
280     if (!HcfIsClassMatch(self, GetVerifyClass())) {
281         LOGE("Class not match.");
282         return;
283     }
284     HcfVerifyImpl *impl = (HcfVerifyImpl *)self;
285     HcfObjDestroy(impl->spiObj);
286     impl->spiObj = NULL;
287     HcfFree(impl);
288 }
289 
SetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t saltLen)290 static HcfResult SetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t saltLen)
291 {
292     if (self == NULL) {
293         LOGE("Invalid input parameter.");
294         return HCF_INVALID_PARAMS;
295     }
296     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
297         LOGE("Class not match.");
298         return HCF_INVALID_PARAMS;
299     }
300     HcfSignImpl *tmpSelf = (HcfSignImpl *)self;
301     return tmpSelf->spiObj->engineSetSignSpecInt(tmpSelf->spiObj, item, saltLen);
302 }
303 
GetSignSpecString(HcfSign *self, SignSpecItem item, char **returnString)304 static HcfResult GetSignSpecString(HcfSign *self, SignSpecItem item, char **returnString)
305 {
306     if (self == NULL || returnString == NULL) {
307         LOGE("Invalid input parameter.");
308         return HCF_INVALID_PARAMS;
309     }
310     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
311         LOGE("Class not match.");
312         return HCF_INVALID_PARAMS;
313     }
314     HcfSignImpl *tmpSelf = (HcfSignImpl *)self;
315     return tmpSelf->spiObj->engineGetSignSpecString(tmpSelf->spiObj, item, returnString);
316 }
317 
SetSignSpecUint8Array(HcfSign *self, SignSpecItem item, HcfBlob blob)318 static HcfResult SetSignSpecUint8Array(HcfSign *self, SignSpecItem item, HcfBlob blob)
319 {
320     if (self == NULL) {
321         LOGE("Invalid input parameter.");
322         return HCF_INVALID_PARAMS;
323     }
324     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
325         LOGE("Class not match.");
326         return HCF_INVALID_PARAMS;
327     }
328     HcfSignImpl *tmpSelf = (HcfSignImpl *)self;
329     return tmpSelf->spiObj->engineSetSignSpecUint8Array(tmpSelf->spiObj, item, blob);
330 }
331 
GetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t *returnInt)332 static HcfResult GetSignSpecInt(HcfSign *self, SignSpecItem item, int32_t *returnInt)
333 {
334     if (self == NULL || returnInt == NULL) {
335         LOGE("Invalid input parameter.");
336         return HCF_INVALID_PARAMS;
337     }
338     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
339         LOGE("Class not match.");
340         return HCF_INVALID_PARAMS;
341     }
342     HcfSignImpl *tmpSelf = (HcfSignImpl *)self;
343     return tmpSelf->spiObj->engineGetSignSpecInt(tmpSelf->spiObj, item, returnInt);
344 }
345 
SignInit(HcfSign *self, HcfParamsSpec *params, HcfPriKey *privateKey)346 static HcfResult SignInit(HcfSign *self, HcfParamsSpec *params, HcfPriKey *privateKey)
347 {
348     if (self == NULL) {
349         LOGE("Invalid input parameter.");
350         return HCF_INVALID_PARAMS;
351     }
352 
353     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
354         LOGE("Class not match.");
355         return HCF_INVALID_PARAMS;
356     }
357     return ((HcfSignImpl *)self)->spiObj->engineInit(((HcfSignImpl *)self)->spiObj, params, privateKey);
358 }
359 
SignUpdate(HcfSign *self, HcfBlob *data)360 static HcfResult SignUpdate(HcfSign *self, HcfBlob *data)
361 {
362     if (self == NULL) {
363         LOGE("Invalid input parameter.");
364         return HCF_INVALID_PARAMS;
365     }
366 
367     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
368         LOGE("Class not match.");
369         return HCF_INVALID_PARAMS;
370     }
371     return ((HcfSignImpl *)self)->spiObj->engineUpdate(((HcfSignImpl *)self)->spiObj, data);
372 }
373 
SignDoFinal(HcfSign *self, HcfBlob *data, HcfBlob *returnSignatureData)374 static HcfResult SignDoFinal(HcfSign *self, HcfBlob *data, HcfBlob *returnSignatureData)
375 {
376     if (self == NULL) {
377         LOGE("Invalid input parameter.");
378         return HCF_INVALID_PARAMS;
379     }
380 
381     if (!HcfIsClassMatch((HcfObjectBase *)self, GetSignClass())) {
382         LOGE("Class not match.");
383         return HCF_INVALID_PARAMS;
384     }
385     return ((HcfSignImpl *)self)->spiObj->engineSign(((HcfSignImpl *)self)->spiObj, data, returnSignatureData);
386 }
387 
SetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t saltLen)388 static HcfResult SetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t saltLen)
389 {
390     if (self == NULL) {
391         LOGE("Invalid input parameter.");
392         return HCF_INVALID_PARAMS;
393     }
394     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
395         LOGE("Class not match.");
396         return HCF_INVALID_PARAMS;
397     }
398     HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self;
399     return tmpSelf->spiObj->engineSetVerifySpecInt(tmpSelf->spiObj, item, saltLen);
400 }
401 
GetVerifySpecString(HcfVerify *self, SignSpecItem item, char **returnString)402 static HcfResult GetVerifySpecString(HcfVerify *self, SignSpecItem item, char **returnString)
403 {
404     if (self == NULL || returnString == NULL) {
405         LOGE("Invalid input parameter.");
406         return HCF_INVALID_PARAMS;
407     }
408     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
409         LOGE("Class not match.");
410         return HCF_INVALID_PARAMS;
411     }
412     HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self;
413     return tmpSelf->spiObj->engineGetVerifySpecString(tmpSelf->spiObj, item, returnString);
414 }
415 
SetVerifySpecUint8Array(HcfVerify *self, SignSpecItem item, HcfBlob blob)416 static HcfResult SetVerifySpecUint8Array(HcfVerify *self, SignSpecItem item, HcfBlob blob)
417 {
418     if (self == NULL) {
419         LOGE("Invalid input parameter.");
420         return HCF_INVALID_PARAMS;
421     }
422     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
423         LOGE("Class not match.");
424         return HCF_INVALID_PARAMS;
425     }
426     HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self;
427     return tmpSelf->spiObj->engineSetVerifySpecUint8Array(tmpSelf->spiObj, item, blob);
428 }
429 
GetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t *returnInt)430 static HcfResult GetVerifySpecInt(HcfVerify *self, SignSpecItem item, int32_t *returnInt)
431 {
432     if (self == NULL || returnInt == NULL) {
433         LOGE("Invalid input parameter.");
434         return HCF_INVALID_PARAMS;
435     }
436     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
437         LOGE("Class not match.");
438         return HCF_INVALID_PARAMS;
439     }
440     HcfVerifyImpl *tmpSelf = (HcfVerifyImpl *)self;
441     return tmpSelf->spiObj->engineGetVerifySpecInt(tmpSelf->spiObj, item, returnInt);
442 }
443 
VerifyInit(HcfVerify *self, HcfParamsSpec *params, HcfPubKey *publicKey)444 static HcfResult VerifyInit(HcfVerify *self, HcfParamsSpec *params, HcfPubKey *publicKey)
445 {
446     if (self == NULL) {
447         LOGE("Invalid input parameter.");
448         return HCF_INVALID_PARAMS;
449     }
450 
451     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
452         LOGE("Class not match.");
453         return HCF_INVALID_PARAMS;
454     }
455     return ((HcfVerifyImpl *)self)->spiObj->engineInit(((HcfVerifyImpl *)self)->spiObj, params, publicKey);
456 }
457 
VerifyUpdate(HcfVerify *self, HcfBlob *data)458 static HcfResult VerifyUpdate(HcfVerify *self, HcfBlob *data)
459 {
460     if (self == NULL) {
461         LOGE("Invalid input parameter.");
462         return HCF_INVALID_PARAMS;
463     }
464 
465     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
466         LOGE("Class not match.");
467         return HCF_INVALID_PARAMS;
468     }
469     return ((HcfVerifyImpl *)self)->spiObj->engineUpdate(((HcfVerifyImpl *)self)->spiObj, data);
470 }
471 
VerifyDoFinal(HcfVerify *self, HcfBlob *data, HcfBlob *signatureData)472 static bool VerifyDoFinal(HcfVerify *self, HcfBlob *data, HcfBlob *signatureData)
473 {
474     if (self == NULL) {
475         LOGE("Invalid input parameter.");
476         return false;
477     }
478     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
479         LOGE("Class not match.");
480         return false;
481     }
482     return ((HcfVerifyImpl *)self)->spiObj->engineVerify(((HcfVerifyImpl *)self)->spiObj, data, signatureData);
483 }
484 
VerifyRecover(HcfVerify *self, HcfBlob *signatureData, HcfBlob *rawSignatureData)485 static HcfResult VerifyRecover(HcfVerify *self, HcfBlob *signatureData, HcfBlob *rawSignatureData)
486 {
487     if (self == NULL) {
488         LOGE("Invalid input parameter.");
489         return HCF_INVALID_PARAMS;
490     }
491     if (!HcfIsClassMatch((HcfObjectBase *)self, GetVerifyClass())) {
492         LOGE("Class not match.");
493         return HCF_INVALID_PARAMS;
494     }
495     HcfVerifySpi *verifySpiObj = ((HcfVerifyImpl *)self)->spiObj;
496     if (verifySpiObj->engineRecover == NULL) {
497         LOGE("Not support verify recover operation.");
498         return HCF_INVALID_PARAMS;
499     }
500 
501     return verifySpiObj->engineRecover(verifySpiObj, signatureData, rawSignatureData);
502 }
503 
HcfSignCreate(const char *algoName, HcfSign **returnObj)504 HcfResult HcfSignCreate(const char *algoName, HcfSign **returnObj)
505 {
506     LOGD("HcfSignCreate start");
507     if ((!HcfIsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) {
508         return HCF_INVALID_PARAMS;
509     }
510 
511     HcfSignatureParams params = { 0 };
512     if (ParseAndSetParameter(algoName, &params, ParseSignatureParams) != HCF_SUCCESS) {
513         LOGE("Failed to parse params!");
514         return HCF_INVALID_PARAMS;
515     }
516 
517     HcfSignSpiCreateFunc createSpiFunc = FindSignAbility(&params);
518     if (createSpiFunc == NULL) {
519         LOGE("Can not find ability.");
520         return HCF_NOT_SUPPORT;
521     }
522 
523     HcfSignImpl *returnSign = (HcfSignImpl *)HcfMalloc(sizeof(HcfSignImpl), 0);
524     if (returnSign == NULL) {
525         LOGE("Failed to allocate returnSign memory!");
526         return HCF_ERR_MALLOC;
527     }
528     if (strcpy_s(returnSign->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) {
529         LOGE("Failed to copy algoName!");
530         HcfFree(returnSign);
531         return HCF_INVALID_PARAMS;
532     }
533     HcfSignSpi *spiObj = NULL;
534     HcfResult res = createSpiFunc(&params, &spiObj);
535     if (res != HCF_SUCCESS) {
536         LOGE("Failed to create spi object!");
537         HcfFree(returnSign);
538         return res;
539     }
540     returnSign->base.base.destroy = DestroySign;
541     returnSign->base.base.getClass = GetSignClass;
542     returnSign->base.getAlgoName = GetSignAlgoName;
543     returnSign->base.init = SignInit;
544     returnSign->base.update = SignUpdate;
545     returnSign->base.sign = SignDoFinal;
546     returnSign->base.setSignSpecInt = SetSignSpecInt;
547     returnSign->base.getSignSpecInt = GetSignSpecInt;
548     returnSign->base.getSignSpecString = GetSignSpecString;
549     returnSign->base.setSignSpecUint8Array = SetSignSpecUint8Array;
550     returnSign->spiObj = spiObj;
551 
552     *returnObj = (HcfSign *)returnSign;
553     LOGD("HcfSignCreate end");
554     return HCF_SUCCESS;
555 }
556 
HcfVerifyCreate(const char *algoName, HcfVerify **returnObj)557 HcfResult HcfVerifyCreate(const char *algoName, HcfVerify **returnObj)
558 {
559     LOGD("HcfVerifyCreate start");
560     if ((!HcfIsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) {
561         return HCF_INVALID_PARAMS;
562     }
563     HcfSignatureParams params = {0};
564     if (ParseAndSetParameter(algoName, &params, ParseSignatureParams) != HCF_SUCCESS) {
565         LOGE("Failed to parse params!");
566         return HCF_INVALID_PARAMS;
567     }
568 
569     HcfVerifySpiCreateFunc createSpiFunc = FindVerifyAbility(&params);
570     if (createSpiFunc == NULL) {
571         return HCF_NOT_SUPPORT;
572     }
573 
574     HcfVerifyImpl *returnVerify = (HcfVerifyImpl *)HcfMalloc(sizeof(HcfVerifyImpl), 0);
575     if (returnVerify == NULL) {
576         LOGE("Failed to allocate returnVerify memory!");
577         return HCF_ERR_MALLOC;
578     }
579     if (strcpy_s(returnVerify->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) {
580         LOGE("Failed to copy algoName!");
581         HcfFree(returnVerify);
582         return HCF_INVALID_PARAMS;
583     }
584     HcfVerifySpi *spiObj = NULL;
585     HcfResult res = createSpiFunc(&params, &spiObj);
586     if (res != HCF_SUCCESS) {
587         LOGE("Failed to create spi object!");
588         HcfFree(returnVerify);
589         return res;
590     }
591     returnVerify->base.base.destroy = DestroyVerify;
592     returnVerify->base.base.getClass = GetVerifyClass;
593     returnVerify->base.getAlgoName = GetVerifyAlgoName;
594     returnVerify->base.init = VerifyInit;
595     returnVerify->base.update = VerifyUpdate;
596     returnVerify->base.verify = VerifyDoFinal;
597     returnVerify->base.recover = VerifyRecover;
598     returnVerify->base.setVerifySpecInt = SetVerifySpecInt;
599     returnVerify->base.getVerifySpecInt = GetVerifySpecInt;
600     returnVerify->base.getVerifySpecString = GetVerifySpecString;
601     returnVerify->base.setVerifySpecUint8Array = SetVerifySpecUint8Array;
602     returnVerify->spiObj = spiObj;
603     *returnObj = (HcfVerify *)returnVerify;
604     LOGD("HcfVerifyCreate end");
605     return HCF_SUCCESS;
606 }
607