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