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