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 "asy_key_params.h"
17
18 #include <stdio.h>
19 #include <string.h>
20 #include <securec.h>
21 #include "params_parser.h"
22 #include "big_integer.h"
23 #include "detailed_dsa_key_params.h"
24 #include "detailed_dh_key_params.h"
25 #include "detailed_ecc_key_params.h"
26 #include "detailed_rsa_key_params.h"
27 #include "detailed_alg_25519_key_params.h"
28 #include "sm2_crypto_params.h"
29 #include "memory.h"
30 #include "log.h"
31
32 #define ALG_NAME_DSA "DSA"
33 #define ALG_NAME_ECC "ECC"
34 #define ALG_NAME_SM2 "SM2"
35 #define ALG_NAME_RSA "RSA"
36 #define ALG_NAME_DH "DH"
37 #define ALG_NAME_ED25519 "Ed25519"
38 #define ALG_NAME_X25519 "X25519"
39
40 typedef void (*HcfFreeParamsAsyKeySpec)(HcfAsyKeyParamsSpec *);
41
42 typedef struct {
43 char *algo;
44
45 HcfFreeParamsAsyKeySpec createFreeFunc;
46 } HcfFreeAsyKeySpec;
47
FreeDsaCommParamsSpec(HcfDsaCommParamsSpec * spec)48 void FreeDsaCommParamsSpec(HcfDsaCommParamsSpec *spec)
49 {
50 if (spec == NULL) {
51 return;
52 }
53 HcfFree(spec->base.algName);
54 spec->base.algName = NULL;
55 HcfFree(spec->p.data);
56 spec->p.data = NULL;
57 HcfFree(spec->q.data);
58 spec->q.data = NULL;
59 HcfFree(spec->g.data);
60 spec->g.data = NULL;
61 }
62
FreeDhCommParamsSpec(HcfDhCommParamsSpec * spec)63 void FreeDhCommParamsSpec(HcfDhCommParamsSpec *spec)
64 {
65 if (spec == NULL) {
66 return;
67 }
68 HcfFree(spec->base.algName);
69 spec->base.algName = NULL;
70 HcfFree(spec->p.data);
71 spec->p.data = NULL;
72 HcfFree(spec->g.data);
73 spec->g.data = NULL;
74 }
75
DestroyDsaCommParamsSpec(HcfDsaCommParamsSpec * spec)76 static void DestroyDsaCommParamsSpec(HcfDsaCommParamsSpec *spec)
77 {
78 FreeDsaCommParamsSpec(spec);
79 HcfFree(spec);
80 }
81
DestroyDsaPubKeySpec(HcfDsaPubKeyParamsSpec * spec)82 void DestroyDsaPubKeySpec(HcfDsaPubKeyParamsSpec *spec)
83 {
84 if (spec == NULL) {
85 return;
86 }
87 FreeDsaCommParamsSpec(&(spec->base));
88 HcfFree(spec->pk.data);
89 spec->pk.data = NULL;
90 HcfFree(spec);
91 }
92
DestroyDsaKeyPairSpec(HcfDsaKeyPairParamsSpec * spec)93 void DestroyDsaKeyPairSpec(HcfDsaKeyPairParamsSpec *spec)
94 {
95 if (spec == NULL) {
96 return;
97 }
98 FreeDsaCommParamsSpec(&(spec->base));
99 HcfFree(spec->pk.data);
100 spec->pk.data = NULL;
101 if (spec->sk.data != NULL) {
102 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
103 HcfFree(spec->sk.data);
104 spec->sk.data = NULL;
105 }
106 HcfFree(spec);
107 }
108
DestroyDhCommParamsSpec(HcfDhCommParamsSpec * spec)109 static void DestroyDhCommParamsSpec(HcfDhCommParamsSpec *spec)
110 {
111 FreeDhCommParamsSpec(spec);
112 HcfFree(spec);
113 }
114
DestroyDhPubKeySpec(HcfDhPubKeyParamsSpec * spec)115 void DestroyDhPubKeySpec(HcfDhPubKeyParamsSpec *spec)
116 {
117 if (spec == NULL) {
118 return;
119 }
120 FreeDhCommParamsSpec(&(spec->base));
121 HcfFree(spec->pk.data);
122 spec->pk.data = NULL;
123 HcfFree(spec);
124 }
125
DestroyDhPriKeySpec(HcfDhPriKeyParamsSpec * spec)126 void DestroyDhPriKeySpec(HcfDhPriKeyParamsSpec *spec)
127 {
128 if (spec == NULL) {
129 return;
130 }
131 FreeDhCommParamsSpec(&(spec->base));
132 if (spec->sk.data != NULL) {
133 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
134 HcfFree(spec->sk.data);
135 spec->sk.data = NULL;
136 }
137 HcfFree(spec);
138 }
139
DestroyDhKeyPairSpec(HcfDhKeyPairParamsSpec * spec)140 void DestroyDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec)
141 {
142 if (spec == NULL) {
143 return;
144 }
145 FreeDhCommParamsSpec(&(spec->base));
146 HcfFree(spec->pk.data);
147 spec->pk.data = NULL;
148 if (spec->sk.data != NULL) {
149 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
150 HcfFree(spec->sk.data);
151 spec->sk.data = NULL;
152 }
153 HcfFree(spec);
154 }
155
FreeEcFieldMem(HcfECField ** field)156 static void FreeEcFieldMem(HcfECField **field)
157 {
158 HcfFree((*field)->fieldType);
159 (*field)->fieldType = NULL;
160 HcfFree(((HcfECFieldFp *)(*field))->p.data);
161 ((HcfECFieldFp *)(*field))->p.data = NULL;
162 HcfFree(*field);
163 *field = NULL;
164 }
165
FreeEcPointMem(HcfPoint * point)166 void FreeEcPointMem(HcfPoint *point)
167 {
168 if (point == NULL) {
169 return;
170 }
171 HcfFree(point->x.data);
172 point->x.data = NULL;
173 HcfFree(point->y.data);
174 point->y.data = NULL;
175 }
176
FreeEccCommParamsSpec(HcfEccCommParamsSpec * spec)177 void FreeEccCommParamsSpec(HcfEccCommParamsSpec *spec)
178 {
179 if (spec == NULL) {
180 return;
181 }
182 HcfFree(spec->base.algName);
183 spec->base.algName = NULL;
184 HcfFree(spec->a.data);
185 spec->a.data = NULL;
186 HcfFree(spec->b.data);
187 spec->b.data = NULL;
188 HcfFree(spec->n.data);
189 spec->n.data = NULL;
190 if (spec->field != NULL) {
191 FreeEcFieldMem(&(spec->field));
192 spec->field = NULL;
193 }
194 FreeEcPointMem(&(spec->g));
195 }
196
DestroyEccCommParamsSpec(HcfEccCommParamsSpec * spec)197 static void DestroyEccCommParamsSpec(HcfEccCommParamsSpec *spec)
198 {
199 FreeEccCommParamsSpec(spec);
200 HcfFree(spec);
201 }
202
DestroyEccPubKeySpec(HcfEccPubKeyParamsSpec * spec)203 void DestroyEccPubKeySpec(HcfEccPubKeyParamsSpec *spec)
204 {
205 if (spec == NULL) {
206 return;
207 }
208 FreeEccCommParamsSpec(&(spec->base));
209 FreeEcPointMem(&(spec->pk));
210 HcfFree(spec);
211 }
212
DestroyEccPriKeySpec(HcfEccPriKeyParamsSpec * spec)213 void DestroyEccPriKeySpec(HcfEccPriKeyParamsSpec *spec)
214 {
215 if (spec == NULL) {
216 return;
217 }
218 FreeEccCommParamsSpec(&(spec->base));
219 if (spec->sk.data != NULL) {
220 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
221 HcfFree(spec->sk.data);
222 spec->sk.data = NULL;
223 }
224 HcfFree(spec);
225 }
226
DestroyEccKeyPairSpec(HcfEccKeyPairParamsSpec * spec)227 void DestroyEccKeyPairSpec(HcfEccKeyPairParamsSpec *spec)
228 {
229 if (spec == NULL) {
230 return;
231 }
232 FreeEccCommParamsSpec(&(spec->base));
233 FreeEcPointMem(&(spec->pk));
234 if (spec->sk.data != NULL) {
235 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
236 HcfFree(spec->sk.data);
237 spec->sk.data = NULL;
238 }
239 HcfFree(spec);
240 }
241
FreeRsaCommParamsSpec(HcfRsaCommParamsSpec * spec)242 void FreeRsaCommParamsSpec(HcfRsaCommParamsSpec *spec)
243 {
244 if (spec == NULL) {
245 return;
246 }
247 HcfFree(spec->base.algName);
248 spec->base.algName = NULL;
249 HcfFree(spec->n.data);
250 spec->n.data = NULL;
251 }
252
DestroyRsaCommParamsSpec(HcfRsaCommParamsSpec * spec)253 static void DestroyRsaCommParamsSpec(HcfRsaCommParamsSpec *spec)
254 {
255 FreeRsaCommParamsSpec(spec);
256 HcfFree(spec);
257 }
258
DestroyRsaPubKeySpec(HcfRsaPubKeyParamsSpec * spec)259 void DestroyRsaPubKeySpec(HcfRsaPubKeyParamsSpec *spec)
260 {
261 if (spec == NULL) {
262 return;
263 }
264 FreeRsaCommParamsSpec(&(spec->base));
265 HcfFree(spec->pk.data);
266 spec->pk.data = NULL;
267 HcfFree(spec);
268 }
269
DestroyRsaKeyPairSpec(HcfRsaKeyPairParamsSpec * spec)270 void DestroyRsaKeyPairSpec(HcfRsaKeyPairParamsSpec *spec)
271 {
272 if (spec == NULL) {
273 return;
274 }
275 FreeRsaCommParamsSpec(&(spec->base));
276 HcfFree(spec->pk.data);
277 spec->pk.data = NULL;
278 if (spec->sk.data != NULL) {
279 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
280 HcfFree(spec->sk.data);
281 spec->sk.data = NULL;
282 }
283 HcfFree(spec);
284 }
285
DestroyDsaParamsSpec(HcfAsyKeyParamsSpec * spec)286 static void DestroyDsaParamsSpec(HcfAsyKeyParamsSpec *spec)
287 {
288 switch (spec->specType) {
289 case HCF_COMMON_PARAMS_SPEC:
290 DestroyDsaCommParamsSpec((HcfDsaCommParamsSpec *)spec);
291 break;
292 case HCF_PUBLIC_KEY_SPEC:
293 DestroyDsaPubKeySpec((HcfDsaPubKeyParamsSpec *)spec);
294 break;
295 case HCF_KEY_PAIR_SPEC:
296 DestroyDsaKeyPairSpec((HcfDsaKeyPairParamsSpec *)spec);
297 break;
298 default:
299 LOGE("No matching DSA key params spec type.");
300 break;
301 }
302 }
303
DestroyDhParamsSpec(HcfAsyKeyParamsSpec * spec)304 static void DestroyDhParamsSpec(HcfAsyKeyParamsSpec *spec)
305 {
306 switch (spec->specType) {
307 case HCF_COMMON_PARAMS_SPEC:
308 DestroyDhCommParamsSpec((HcfDhCommParamsSpec *)spec);
309 break;
310 case HCF_PUBLIC_KEY_SPEC:
311 DestroyDhPubKeySpec((HcfDhPubKeyParamsSpec *)spec);
312 break;
313 case HCF_PRIVATE_KEY_SPEC:
314 DestroyDhPriKeySpec((HcfDhPriKeyParamsSpec *)spec);
315 break;
316 case HCF_KEY_PAIR_SPEC:
317 DestroyDhKeyPairSpec((HcfDhKeyPairParamsSpec *)spec);
318 break;
319 default:
320 LOGE("No matching DH key params spec type.");
321 break;
322 }
323 }
324
DestroyEccParamsSpec(HcfAsyKeyParamsSpec * spec)325 static void DestroyEccParamsSpec(HcfAsyKeyParamsSpec *spec)
326 {
327 switch (spec->specType) {
328 case HCF_COMMON_PARAMS_SPEC:
329 DestroyEccCommParamsSpec((HcfEccCommParamsSpec *)spec);
330 break;
331 case HCF_PRIVATE_KEY_SPEC:
332 DestroyEccPriKeySpec((HcfEccPriKeyParamsSpec *)spec);
333 break;
334 case HCF_PUBLIC_KEY_SPEC:
335 DestroyEccPubKeySpec((HcfEccPubKeyParamsSpec *)spec);
336 break;
337 case HCF_KEY_PAIR_SPEC:
338 DestroyEccKeyPairSpec((HcfEccKeyPairParamsSpec *)spec);
339 break;
340 default:
341 LOGE("No matching ECC key params spec type.");
342 break;
343 }
344 }
345
DestroyRsaParamsSpec(HcfAsyKeyParamsSpec * spec)346 static void DestroyRsaParamsSpec(HcfAsyKeyParamsSpec *spec)
347 {
348 switch (spec->specType) {
349 case HCF_COMMON_PARAMS_SPEC:
350 DestroyRsaCommParamsSpec((HcfRsaCommParamsSpec *)spec);
351 break;
352 case HCF_PUBLIC_KEY_SPEC:
353 DestroyRsaPubKeySpec((HcfRsaPubKeyParamsSpec *)spec);
354 break;
355 case HCF_KEY_PAIR_SPEC:
356 DestroyRsaKeyPairSpec((HcfRsaKeyPairParamsSpec *)spec);
357 break;
358 default:
359 LOGE("No matching RSA key params spec type.");
360 break;
361 }
362 }
363
DestroyAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec * spec)364 void DestroyAlg25519PubKeySpec(HcfAlg25519PubKeyParamsSpec *spec)
365 {
366 if (spec == NULL) {
367 return;
368 }
369 if (spec->pk.data != NULL) {
370 (void)memset_s(spec->pk.data, spec->pk.len, 0, spec->pk.len);
371 HcfFree(spec->pk.data);
372 spec->pk.data = NULL;
373 }
374 if (spec->base.algName != NULL) {
375 HcfFree(spec->base.algName);
376 spec->base.algName = NULL;
377 }
378 HcfFree(spec);
379 }
380
DestroyAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec * spec)381 void DestroyAlg25519PriKeySpec(HcfAlg25519PriKeyParamsSpec *spec)
382 {
383 if (spec == NULL) {
384 return;
385 }
386 if (spec->sk.data != NULL) {
387 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
388 HcfFree(spec->sk.data);
389 spec->sk.data = NULL;
390 }
391 if (spec->base.algName != NULL) {
392 HcfFree(spec->base.algName);
393 spec->base.algName = NULL;
394 }
395 HcfFree(spec);
396 }
397
DestroyAlg25519KeyPairSpec(HcfAlg25519KeyPairParamsSpec * spec)398 void DestroyAlg25519KeyPairSpec(HcfAlg25519KeyPairParamsSpec *spec)
399 {
400 if (spec == NULL) {
401 return;
402 }
403 if (spec->pk.data != NULL) {
404 (void)memset_s(spec->pk.data, spec->pk.len, 0, spec->pk.len);
405 HcfFree(spec->pk.data);
406 spec->pk.data = NULL;
407 }
408 if (spec->sk.data != NULL) {
409 (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
410 HcfFree(spec->sk.data);
411 spec->sk.data = NULL;
412 }
413 if (spec->base.algName != NULL) {
414 HcfFree(spec->base.algName);
415 spec->base.algName = NULL;
416 }
417 HcfFree(spec);
418 }
419
DestroyAlg25519ParamsSpec(HcfAsyKeyParamsSpec * spec)420 static void DestroyAlg25519ParamsSpec(HcfAsyKeyParamsSpec *spec)
421 {
422 switch (spec->specType) {
423 case HCF_PUBLIC_KEY_SPEC:
424 DestroyAlg25519PubKeySpec((HcfAlg25519PubKeyParamsSpec *)spec);
425 break;
426 case HCF_PRIVATE_KEY_SPEC:
427 DestroyAlg25519PriKeySpec((HcfAlg25519PriKeyParamsSpec *)spec);
428 break;
429 case HCF_KEY_PAIR_SPEC:
430 DestroyAlg25519KeyPairSpec((HcfAlg25519KeyPairParamsSpec *)spec);
431 break;
432 default:
433 LOGE("No matching alg25519 key params spec type.");
434 break;
435 }
436 }
437
438 static HcfFreeAsyKeySpec g_asyKeyFreeAbility[] = {
439 { ALG_NAME_DSA, DestroyDsaParamsSpec },
440 { ALG_NAME_ECC, DestroyEccParamsSpec },
441 { ALG_NAME_SM2, DestroyEccParamsSpec },
442 { ALG_NAME_RSA, DestroyRsaParamsSpec },
443 { ALG_NAME_X25519, DestroyAlg25519ParamsSpec },
444 { ALG_NAME_ED25519, DestroyAlg25519ParamsSpec },
445 { ALG_NAME_DH, DestroyDhParamsSpec }
446 };
447
FindAsyKeySpecFreeAbility(HcfAsyKeyParamsSpec * spec)448 static HcfFreeParamsAsyKeySpec FindAsyKeySpecFreeAbility(HcfAsyKeyParamsSpec *spec)
449 {
450 for (uint32_t i = 0; i < sizeof(g_asyKeyFreeAbility) / sizeof(g_asyKeyFreeAbility[0]); i++) {
451 if (strcmp(spec->algName, g_asyKeyFreeAbility[i].algo) == 0) {
452 return g_asyKeyFreeAbility[i].createFreeFunc;
453 }
454 }
455 LOGE("No matching key params spec alg name! [Algo]: %{public}s", spec->algName);
456 return NULL;
457 }
458
FreeAsyKeySpec(HcfAsyKeyParamsSpec * spec)459 void FreeAsyKeySpec(HcfAsyKeyParamsSpec *spec)
460 {
461 if (spec == NULL || spec->algName == NULL) {
462 LOGE("Invalid input parameter.");
463 return;
464 }
465 HcfFreeParamsAsyKeySpec createFreeFunc = FindAsyKeySpecFreeAbility(spec);
466 if (createFreeFunc != NULL) {
467 createFreeFunc(spec);
468 } else {
469 LOGE("create freeFunc failed.");
470 }
471 }
472
DestroySm2CipherTextSpec(Sm2CipherTextSpec * spec)473 void DestroySm2CipherTextSpec(Sm2CipherTextSpec *spec)
474 {
475 if (spec == NULL) {
476 return;
477 }
478 HcfFree(spec->xCoordinate.data);
479 spec->xCoordinate.data = NULL;
480 HcfFree(spec->yCoordinate.data);
481 spec->yCoordinate.data = NULL;
482 HcfBlobDataFree(&(spec->cipherTextData));
483 HcfBlobDataFree(&(spec->hashData));
484 HcfFree(spec);
485 }
486
DestroySm2EcSignatureSpec(Sm2EcSignatureDataSpec * spec)487 void DestroySm2EcSignatureSpec(Sm2EcSignatureDataSpec *spec)
488 {
489 if (spec == NULL) {
490 return;
491 }
492 HcfFree(spec->rCoordinate.data);
493 spec->rCoordinate.data = NULL;
494 HcfFree(spec->sCoordinate.data);
495 spec->sCoordinate.data = NULL;
496 HcfFree(spec);
497 }
498