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 "asy_key_generator.h"
17 
18 #include <securec.h>
19 
20 #include "asy_key_generator_spi.h"
21 #include "config.h"
22 #include "detailed_alg_25519_key_params.h"
23 #include "detailed_dh_key_params.h"
24 #include "detailed_dsa_key_params.h"
25 #include "detailed_rsa_key_params.h"
26 #include "detailed_ecc_key_params.h"
27 #include "dh_asy_key_generator_openssl.h"
28 #include "dsa_asy_key_generator_openssl.h"
29 #include "alg_25519_asy_key_generator_openssl.h"
30 #include "ecc_asy_key_generator_openssl.h"
31 #include "key_utils.h"
32 #include "params_parser.h"
33 #include "rsa_asy_key_generator_openssl.h"
34 #include "sm2_asy_key_generator_openssl.h"
35 #include "log.h"
36 #include "memory.h"
37 #include "utils.h"
38 
39 #define ALG_NAME_DSA "DSA"
40 #define ALG_NAME_ECC "ECC"
41 #define ALG_NAME_SM2 "SM2"
42 #define ALG_NAME_RSA "RSA"
43 #define ALG_NAME_DH "DH"
44 #define ALG_NAME_X25519 "X25519"
45 #define ALG_NAME_ED25519 "Ed25519"
46 #define ASY_KEY_GENERATOR_CLASS "HcfAsyKeyGenerator"
47 #define ASY_KEY_GENERATOR_BY_SPEC_CLASS "HcfAsyKeyGeneratorBySpec"
48 
49 typedef HcfResult (*HcfAsyKeyGeneratorSpiCreateFunc)(HcfAsyKeyGenParams *, HcfAsyKeyGeneratorSpi **);
50 
51 typedef struct {
52     HcfAsyKeyGenerator base;
53 
54     HcfAsyKeyGeneratorSpi *spiObj;
55 
56     char algoName[HCF_MAX_ALGO_NAME_LEN];
57 } HcfAsyKeyGeneratorImpl;
58 
59 typedef struct {
60     HcfAsyKeyGeneratorBySpec base;
61 
62     HcfAsyKeyGeneratorSpi *spiObj;
63 
64     HcfAsyKeyParamsSpec *paramsSpec;
65 } HcfAsyKeyGeneratorBySpecImpl;
66 
67 typedef struct {
68     HcfAlgValue algo;
69 
70     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc;
71 } HcfAsyKeyGenAbility;
72 
73 static const HcfAsyKeyGenAbility ASY_KEY_GEN_ABILITY_SET[] = {
74     { HCF_ALG_RSA, HcfAsyKeyGeneratorSpiRsaCreate },
75     { HCF_ALG_ECC, HcfAsyKeyGeneratorSpiEccCreate },
76     { HCF_ALG_DSA, HcfAsyKeyGeneratorSpiDsaCreate },
77     { HCF_ALG_SM2, HcfAsyKeyGeneratorSpiSm2Create },
78     { HCF_ALG_ED25519, HcfAsyKeyGeneratorSpiEd25519Create },
79     { HCF_ALG_X25519, HcfAsyKeyGeneratorSpiX25519Create },
80     { HCF_ALG_DH, HcfAsyKeyGeneratorSpiDhCreate }
81 };
82 
83 typedef struct {
84     HcfAlgParaValue value;
85     int32_t bits; // keyLen
86     HcfAlgValue algo; // algType
87 } KeyTypeAlg;
88 
89 static const KeyTypeAlg KEY_TYPE_MAP[] = {
90     { HCF_ALG_ECC_224, HCF_ALG_ECC_224, HCF_ALG_ECC },
91     { HCF_ALG_ECC_256, HCF_ALG_ECC_256, HCF_ALG_ECC },
92     { HCF_ALG_ECC_384, HCF_ALG_ECC_384, HCF_ALG_ECC },
93     { HCF_ALG_ECC_521, HCF_ALG_ECC_521, HCF_ALG_ECC },
94     { HCF_OPENSSL_RSA_512, HCF_RSA_KEY_SIZE_512, HCF_ALG_RSA },
95     { HCF_OPENSSL_RSA_768, HCF_RSA_KEY_SIZE_768, HCF_ALG_RSA },
96     { HCF_OPENSSL_RSA_1024, HCF_RSA_KEY_SIZE_1024, HCF_ALG_RSA },
97     { HCF_OPENSSL_RSA_2048, HCF_RSA_KEY_SIZE_2048, HCF_ALG_RSA },
98     { HCF_OPENSSL_RSA_3072, HCF_RSA_KEY_SIZE_3072, HCF_ALG_RSA },
99     { HCF_OPENSSL_RSA_4096, HCF_RSA_KEY_SIZE_4096, HCF_ALG_RSA },
100     { HCF_OPENSSL_RSA_4096, HCF_RSA_KEY_SIZE_4096, HCF_ALG_RSA },
101     { HCF_OPENSSL_RSA_8192, HCF_RSA_KEY_SIZE_8192, HCF_ALG_RSA },
102     { HCF_ALG_DSA_1024, HCF_DSA_KEY_SIZE_1024, HCF_ALG_DSA },
103     { HCF_ALG_DSA_2048, HCF_DSA_KEY_SIZE_2048, HCF_ALG_DSA },
104     { HCF_ALG_DSA_3072, HCF_DSA_KEY_SIZE_3072, HCF_ALG_DSA },
105     { HCF_ALG_SM2_256, HCF_ALG_SM2_256, HCF_ALG_SM2 },
106     { HCF_ALG_ECC_BP160R1, HCF_ALG_ECC_BP160R1, HCF_ALG_ECC },
107     { HCF_ALG_ECC_BP160T1, HCF_ALG_ECC_BP160T1, HCF_ALG_ECC },
108     { HCF_ALG_ECC_BP192R1, HCF_ALG_ECC_BP192R1, HCF_ALG_ECC },
109     { HCF_ALG_ECC_BP192T1, HCF_ALG_ECC_BP192T1, HCF_ALG_ECC },
110     { HCF_ALG_ECC_BP224R1, HCF_ALG_ECC_BP224R1, HCF_ALG_ECC },
111     { HCF_ALG_ECC_BP224T1, HCF_ALG_ECC_BP224T1, HCF_ALG_ECC },
112     { HCF_ALG_ECC_BP256R1, HCF_ALG_ECC_BP256R1, HCF_ALG_ECC },
113     { HCF_ALG_ECC_BP256T1, HCF_ALG_ECC_BP256T1, HCF_ALG_ECC },
114     { HCF_ALG_ECC_BP320R1, HCF_ALG_ECC_BP320R1, HCF_ALG_ECC },
115     { HCF_ALG_ECC_BP320T1, HCF_ALG_ECC_BP320T1, HCF_ALG_ECC },
116     { HCF_ALG_ECC_BP384R1, HCF_ALG_ECC_BP384R1, HCF_ALG_ECC },
117     { HCF_ALG_ECC_BP384T1, HCF_ALG_ECC_BP384T1, HCF_ALG_ECC },
118     { HCF_ALG_ECC_BP512R1, HCF_ALG_ECC_BP512R1, HCF_ALG_ECC },
119     { HCF_ALG_ECC_BP512T1, HCF_ALG_ECC_BP512T1, HCF_ALG_ECC },
120     { HCF_ALG_ECC_SECP256K1, HCF_ALG_ECC_SECP256K1, HCF_ALG_ECC },
121     { HCF_ALG_ED25519_256, HCF_ALG_ED25519_256, HCF_ALG_ED25519 },
122     { HCF_ALG_X25519_256, HCF_ALG_X25519_256, HCF_ALG_X25519 },
123     { HCF_OPENSSL_DH_MODP_1536, HCF_DH_MODP_SIZE_1536, HCF_ALG_DH },
124     { HCF_OPENSSL_DH_MODP_2048, HCF_DH_MODP_SIZE_2048, HCF_ALG_DH },
125     { HCF_OPENSSL_DH_MODP_3072, HCF_DH_MODP_SIZE_3072, HCF_ALG_DH },
126     { HCF_OPENSSL_DH_MODP_4096, HCF_DH_MODP_SIZE_4096, HCF_ALG_DH },
127     { HCF_OPENSSL_DH_MODP_6144, HCF_DH_MODP_SIZE_6144, HCF_ALG_DH },
128     { HCF_OPENSSL_DH_MODP_8192, HCF_DH_MODP_SIZE_8192, HCF_ALG_DH },
129     { HCF_OPENSSL_DH_FFDHE_2048, HCF_DH_FFDHE_SIZE_2048, HCF_ALG_DH },
130     { HCF_OPENSSL_DH_FFDHE_3072, HCF_DH_FFDHE_SIZE_3072, HCF_ALG_DH },
131     { HCF_OPENSSL_DH_FFDHE_4096, HCF_DH_FFDHE_SIZE_4096, HCF_ALG_DH },
132     { HCF_OPENSSL_DH_FFDHE_6144, HCF_DH_FFDHE_SIZE_6144, HCF_ALG_DH },
133     { HCF_OPENSSL_DH_FFDHE_8192, HCF_DH_FFDHE_SIZE_8192, HCF_ALG_DH }
134 };
IsDsaCommParamsSpecValid(HcfDsaCommParamsSpec * paramsSpec)135 static bool IsDsaCommParamsSpecValid(HcfDsaCommParamsSpec *paramsSpec)
136 {
137     if ((paramsSpec->p.data == NULL) || (paramsSpec->p.len == 0)) {
138         LOGE("BigInteger p is invalid");
139         return false;
140     }
141     if ((paramsSpec->q.data == NULL) || (paramsSpec->q.len == 0)) {
142         LOGE("BigInteger q is invalid");
143         return false;
144     }
145     if ((paramsSpec->g.data == NULL) || (paramsSpec->g.len == 0)) {
146         LOGE("BigInteger g is invalid");
147         return false;
148     }
149     return true;
150 }
151 
IsDsaPubKeySpecValid(HcfDsaPubKeyParamsSpec * paramsSpec)152 static bool IsDsaPubKeySpecValid(HcfDsaPubKeyParamsSpec *paramsSpec)
153 {
154     if (!IsDsaCommParamsSpecValid(&(paramsSpec->base))) {
155         return false;
156     }
157     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
158         LOGE("BigInteger pk is invalid");
159         return false;
160     }
161     return true;
162 }
163 
IsDsaKeyPairSpecValid(HcfDsaKeyPairParamsSpec * paramsSpec)164 static bool IsDsaKeyPairSpecValid(HcfDsaKeyPairParamsSpec *paramsSpec)
165 {
166     if (!IsDsaCommParamsSpecValid(&(paramsSpec->base))) {
167         return false;
168     }
169     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
170         LOGE("BigInteger pk is invalid");
171         return false;
172     }
173     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
174         LOGE("BigInteger sk is invalid");
175         return false;
176     }
177     return true;
178 }
179 
IsDsaParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)180 static bool IsDsaParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
181 {
182     bool ret = false;
183     switch (paramsSpec->specType) {
184         case HCF_COMMON_PARAMS_SPEC:
185             ret = IsDsaCommParamsSpecValid((HcfDsaCommParamsSpec *)paramsSpec);
186             break;
187         case HCF_PUBLIC_KEY_SPEC:
188             ret = IsDsaPubKeySpecValid((HcfDsaPubKeyParamsSpec *)paramsSpec);
189             break;
190         case HCF_KEY_PAIR_SPEC:
191             ret = IsDsaKeyPairSpecValid((HcfDsaKeyPairParamsSpec *)paramsSpec);
192             break;
193         default:
194             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
195             break;
196     }
197     return ret;
198 }
199 
IsDhCommParamsSpecValid(HcfDhCommParamsSpec * paramsSpec)200 static bool IsDhCommParamsSpecValid(HcfDhCommParamsSpec *paramsSpec)
201 {
202     if ((paramsSpec->p.data == NULL) || (paramsSpec->p.len == 0)) {
203         LOGE("BigInteger p is invalid");
204         return false;
205     }
206     if ((paramsSpec->g.data == NULL) || (paramsSpec->g.len == 0)) {
207         LOGE("BigInteger g is invalid");
208         return false;
209     }
210     return true;
211 }
212 
IsDhPriKeySpecValid(HcfDhPriKeyParamsSpec * paramsSpec)213 static bool IsDhPriKeySpecValid(HcfDhPriKeyParamsSpec *paramsSpec)
214 {
215     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
216         return false;
217     }
218     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
219         LOGE("BigInteger sk is invalid");
220         return false;
221     }
222     return true;
223 }
224 
IsDhPubKeySpecValid(HcfDhPubKeyParamsSpec * paramsSpec)225 static bool IsDhPubKeySpecValid(HcfDhPubKeyParamsSpec *paramsSpec)
226 {
227     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
228         return false;
229     }
230     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
231         LOGE("BigInteger pk is invalid");
232         return false;
233     }
234     return true;
235 }
236 
IsDhKeyPairSpecValid(HcfDhKeyPairParamsSpec * paramsSpec)237 static bool IsDhKeyPairSpecValid(HcfDhKeyPairParamsSpec *paramsSpec)
238 {
239     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
240         return false;
241     }
242     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
243         LOGE("BigInteger pk is invalid");
244         return false;
245     }
246     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
247         LOGE("BigInteger sk is invalid");
248         return false;
249     }
250     return true;
251 }
252 
IsDhParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)253 static bool IsDhParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
254 {
255     bool ret = false;
256     switch (paramsSpec->specType) {
257         case HCF_COMMON_PARAMS_SPEC:
258             ret = IsDhCommParamsSpecValid((HcfDhCommParamsSpec *)paramsSpec);
259             break;
260         case HCF_PRIVATE_KEY_SPEC:
261             ret = IsDhPriKeySpecValid((HcfDhPriKeyParamsSpec *)paramsSpec);
262             break;
263         case HCF_PUBLIC_KEY_SPEC:
264             ret = IsDhPubKeySpecValid((HcfDhPubKeyParamsSpec *)paramsSpec);
265             break;
266         case HCF_KEY_PAIR_SPEC:
267             ret = IsDhKeyPairSpecValid((HcfDhKeyPairParamsSpec *)paramsSpec);
268             break;
269         default:
270             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
271             break;
272     }
273     return ret;
274 }
275 
IsEccCommParamsSpecValid(HcfEccCommParamsSpec * paramsSpec)276 static bool IsEccCommParamsSpecValid(HcfEccCommParamsSpec *paramsSpec)
277 {
278     if ((paramsSpec->a.data == NULL) || (paramsSpec->a.len == 0)) {
279         LOGE("BigInteger a is invalid");
280         return false;
281     }
282     if ((paramsSpec->b.data == NULL) || (paramsSpec->b.len == 0)) {
283         LOGE("BigInteger b is invalid");
284         return false;
285     }
286     if ((paramsSpec->n.data == NULL) || (paramsSpec->n.len == 0)) {
287         LOGE("BigInteger n is invalid");
288         return false;
289     }
290     if ((paramsSpec->g.x.data == NULL) || (paramsSpec->g.x.len == 0) ||
291         (paramsSpec->g.y.data == NULL) || (paramsSpec->g.y.len == 0)) {
292         LOGE("Point g is invalid");
293         return false;
294     }
295     if (paramsSpec->field == NULL) {
296         LOGE("Field is null.");
297         return false;
298     }
299     if (strcmp(paramsSpec->field->fieldType, "Fp") != 0) {
300         LOGE("Unknown field type.");
301         return false;
302     }
303     HcfECFieldFp *tmp = (HcfECFieldFp *)(paramsSpec->field);
304     if ((tmp->p.data == NULL) || (tmp->p.len == 0)) {
305         LOGE("EcFieldFp p is invalid");
306         return false;
307     }
308     return true;
309 }
310 
IsEccPriKeySpecValid(HcfEccPriKeyParamsSpec * paramsSpec)311 static bool IsEccPriKeySpecValid(HcfEccPriKeyParamsSpec *paramsSpec)
312 {
313     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
314         return false;
315     }
316     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
317         LOGE("BigInteger sk is invalid");
318         return false;
319     }
320     return true;
321 }
322 
IsEccPubKeySpecValid(HcfEccPubKeyParamsSpec * paramsSpec)323 static bool IsEccPubKeySpecValid(HcfEccPubKeyParamsSpec *paramsSpec)
324 {
325     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
326         return false;
327     }
328     if ((paramsSpec->pk.x.data == NULL) || (paramsSpec->pk.x.len == 0) ||
329         (paramsSpec->pk.y.data == NULL) || (paramsSpec->pk.y.len == 0)) {
330         LOGE("Point pk is invalid");
331         return false;
332     }
333     return true;
334 }
335 
IsEccKeyPairSpecValid(HcfEccKeyPairParamsSpec * paramsSpec)336 static bool IsEccKeyPairSpecValid(HcfEccKeyPairParamsSpec *paramsSpec)
337 {
338     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
339         return false;
340     }
341     if ((paramsSpec->pk.x.data == NULL) || (paramsSpec->pk.x.len == 0) ||
342         (paramsSpec->pk.y.data == NULL) || (paramsSpec->pk.y.len == 0)) {
343         LOGE("Point pk is invalid");
344         return false;
345     }
346     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
347         LOGE("BigInteger sk is invalid");
348         return false;
349     }
350     return true;
351 }
352 
IsEccParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)353 static bool IsEccParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
354 {
355     bool ret = false;
356     switch (paramsSpec->specType) {
357         case HCF_COMMON_PARAMS_SPEC:
358             ret = IsEccCommParamsSpecValid((HcfEccCommParamsSpec *)paramsSpec);
359             break;
360         case HCF_PRIVATE_KEY_SPEC:
361             ret = IsEccPriKeySpecValid((HcfEccPriKeyParamsSpec *)paramsSpec);
362             break;
363         case HCF_PUBLIC_KEY_SPEC:
364             ret = IsEccPubKeySpecValid((HcfEccPubKeyParamsSpec *)paramsSpec);
365             break;
366         case HCF_KEY_PAIR_SPEC:
367             ret = IsEccKeyPairSpecValid((HcfEccKeyPairParamsSpec *)paramsSpec);
368             break;
369         default:
370             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
371             break;
372     }
373     return ret;
374 }
375 
IsAlg25519PriKeySpecValid(HcfAlg25519PriKeyParamsSpec * paramsSpec)376 static bool IsAlg25519PriKeySpecValid(HcfAlg25519PriKeyParamsSpec *paramsSpec)
377 {
378     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
379         LOGE("Uint8Array sk is invalid");
380         return false;
381     }
382     return true;
383 }
384 
IsAlg25519PubKeySpecValid(HcfAlg25519PubKeyParamsSpec * paramsSpec)385 static bool IsAlg25519PubKeySpecValid(HcfAlg25519PubKeyParamsSpec *paramsSpec)
386 {
387     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
388         LOGE("Uint8Array pk is invalid");
389         return false;
390     }
391     return true;
392 }
393 
IsAlg25519KeyPairSpecValid(HcfAlg25519KeyPairParamsSpec * paramsSpec)394 static bool IsAlg25519KeyPairSpecValid(HcfAlg25519KeyPairParamsSpec *paramsSpec)
395 {
396     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
397         LOGE("Uint8Array pk is invalid");
398         return false;
399     }
400     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
401         LOGE("Uint8Array sk is invalid");
402         return false;
403     }
404     return true;
405 }
406 
IsAlg25519ParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)407 static bool IsAlg25519ParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
408 {
409     bool ret = false;
410     switch (paramsSpec->specType) {
411         case HCF_PRIVATE_KEY_SPEC:
412             ret = IsAlg25519PriKeySpecValid((HcfAlg25519PriKeyParamsSpec *)paramsSpec);
413             break;
414         case HCF_PUBLIC_KEY_SPEC:
415             ret = IsAlg25519PubKeySpecValid((HcfAlg25519PubKeyParamsSpec *)paramsSpec);
416             break;
417         case HCF_KEY_PAIR_SPEC:
418             ret = IsAlg25519KeyPairSpecValid((HcfAlg25519KeyPairParamsSpec *)paramsSpec);
419             break;
420         default:
421             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
422             break;
423     }
424     return ret;
425 }
426 
IsRsaCommParamsSpecValid(HcfRsaCommParamsSpec * paramsSpec)427 static bool IsRsaCommParamsSpecValid(HcfRsaCommParamsSpec *paramsSpec)
428 {
429     if ((paramsSpec->n.data == NULL) || (paramsSpec->n.len == 0)) {
430         LOGE("BigInteger n is invalid");
431         return false;
432     }
433     return true;
434 }
435 
IsRsaPubKeySpecValid(HcfRsaPubKeyParamsSpec * paramsSpec)436 static bool IsRsaPubKeySpecValid(HcfRsaPubKeyParamsSpec *paramsSpec)
437 {
438     if (!IsRsaCommParamsSpecValid(&(paramsSpec->base))) {
439         return false;
440     }
441     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
442         LOGE("BigInteger pk is invalid");
443         return false;
444     }
445     return true;
446 }
447 
IsRsaKeyPairSpecValid(HcfRsaKeyPairParamsSpec * paramsSpec)448 static bool IsRsaKeyPairSpecValid(HcfRsaKeyPairParamsSpec *paramsSpec)
449 {
450     if (!IsRsaCommParamsSpecValid(&(paramsSpec->base))) {
451         return false;
452     }
453     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
454         LOGE("BigInteger pk is invalid");
455         return false;
456     }
457     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
458         LOGE("BigInteger sk is invalid");
459         return false;
460     }
461     return true;
462 }
463 
IsRsaParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)464 static bool IsRsaParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
465 {
466     bool ret = false;
467     switch (paramsSpec->specType) {
468         case HCF_COMMON_PARAMS_SPEC:
469             ret = IsRsaCommParamsSpecValid((HcfRsaCommParamsSpec *)paramsSpec);
470             break;
471         case HCF_PUBLIC_KEY_SPEC:
472             ret = IsRsaPubKeySpecValid((HcfRsaPubKeyParamsSpec *)paramsSpec);
473             break;
474         case HCF_KEY_PAIR_SPEC:
475             ret = IsRsaKeyPairSpecValid((HcfRsaKeyPairParamsSpec *)paramsSpec);
476             break;
477         default:
478             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
479             break;
480     }
481     return ret;
482 }
483 
IsParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)484 static bool IsParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
485 {
486     if ((paramsSpec == NULL) || (paramsSpec->algName == NULL)) {
487         LOGE("Params spec is null");
488         return false;
489     }
490     if (strcmp(paramsSpec->algName, ALG_NAME_DSA) == 0) {
491         return IsDsaParamsSpecValid(paramsSpec);
492     } else if (strcmp(paramsSpec->algName, ALG_NAME_ECC) == 0 || strcmp(paramsSpec->algName, ALG_NAME_SM2) == 0) {
493         return IsEccParamsSpecValid(paramsSpec);
494     } else if (strcmp(paramsSpec->algName, ALG_NAME_RSA) == 0) {
495         return IsRsaParamsSpecValid(paramsSpec);
496     } else if (strcmp(paramsSpec->algName, ALG_NAME_X25519) == 0 ||
497         strcmp(paramsSpec->algName, ALG_NAME_ED25519) == 0) {
498         return IsAlg25519ParamsSpecValid(paramsSpec);
499     } else if (strcmp(paramsSpec->algName, ALG_NAME_DH) == 0) {
500         return IsDhParamsSpecValid(paramsSpec);
501     } else {
502         LOGE("AlgName not support! [AlgName]: %s", paramsSpec->algName);
503         return false;
504     }
505 }
506 
FindAbility(HcfAsyKeyGenParams * params)507 static HcfAsyKeyGeneratorSpiCreateFunc FindAbility(HcfAsyKeyGenParams *params)
508 {
509     for (uint32_t i = 0; i < sizeof(ASY_KEY_GEN_ABILITY_SET) / sizeof(ASY_KEY_GEN_ABILITY_SET[0]); i++) {
510         if (ASY_KEY_GEN_ABILITY_SET[i].algo == params->algo) {
511             return ASY_KEY_GEN_ABILITY_SET[i].createSpiFunc;
512         }
513     }
514     LOGE("Algo not support! [Algo]: %d", params->algo);
515     return NULL;
516 }
517 
SetPrimes(HcfAlgParaValue value,HcfAsyKeyGenParams * params)518 static void SetPrimes(HcfAlgParaValue value, HcfAsyKeyGenParams *params)
519 {
520     if (params == NULL) {
521         LOGE("params is null.");
522         return;
523     }
524     switch (value) {
525         case HCF_OPENSSL_PRIMES_2:
526             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_2;
527             break;
528         case HCF_OPENSSL_PRIMES_3:
529             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_3;
530             break;
531         case HCF_OPENSSL_PRIMES_4:
532             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_4;
533             break;
534         case HCF_OPENSSL_PRIMES_5:
535             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_5;
536             break;
537         default:
538             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_2; // default primes is 2
539             LOGD("user default primes 2");
540             break;
541     }
542     LOGD("Set primes:%d!", params->primes);
543 }
544 
SetKeyType(HcfAlgParaValue value,HcfAsyKeyGenParams * params)545 static void SetKeyType(HcfAlgParaValue value, HcfAsyKeyGenParams *params)
546 {
547     for (uint32_t i = 0; i < sizeof(KEY_TYPE_MAP) / sizeof(KEY_TYPE_MAP[0]); i++) {
548         if (KEY_TYPE_MAP[i].value == value) {
549             params->bits = KEY_TYPE_MAP[i].bits;
550             params->algo = KEY_TYPE_MAP[i].algo;
551             return;
552         }
553     }
554     LOGE("There is not matched algorithm.");
555 }
556 
ParseAsyKeyGenParams(const HcfParaConfig * config,void * params)557 static HcfResult ParseAsyKeyGenParams(const HcfParaConfig* config, void *params)
558 {
559     if (config == NULL || params == NULL) {
560         return HCF_INVALID_PARAMS;
561     }
562     HcfResult ret = HCF_SUCCESS;
563     HcfAsyKeyGenParams *paramsObj = (HcfAsyKeyGenParams *)params;
564     LOGD("Set Parameter: %s", config->tag);
565     switch (config->paraType) {
566         case HCF_ALG_KEY_TYPE:
567             SetKeyType(config->paraValue, paramsObj);
568             break;
569         case HCF_ALG_PRIMES:
570             SetPrimes(config->paraValue, paramsObj);
571             break;
572         default:
573             ret = HCF_INVALID_PARAMS;
574             break;
575     }
576     return ret;
577 }
578 
CopyDsaCommonSpec(const HcfDsaCommParamsSpec * srcSpec,HcfDsaCommParamsSpec * destSpec)579 static HcfResult CopyDsaCommonSpec(const HcfDsaCommParamsSpec *srcSpec, HcfDsaCommParamsSpec *destSpec)
580 {
581     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
582         return HCF_INVALID_PARAMS;
583     }
584     destSpec->p.data = (unsigned char *)HcfMalloc(srcSpec->p.len, 0);
585     if (destSpec->p.data == NULL) {
586         LOGE("Failed to allocate p data memory");
587         FreeDsaCommParamsSpec(destSpec);
588         return HCF_ERR_MALLOC;
589     }
590     destSpec->q.data = (unsigned char *)HcfMalloc(srcSpec->q.len, 0);
591     if (destSpec->q.data == NULL) {
592         LOGE("Failed to allocate q data memory");
593         FreeDsaCommParamsSpec(destSpec);
594         return HCF_ERR_MALLOC;
595     }
596     destSpec->g.data = (unsigned char *)HcfMalloc(srcSpec->g.len, 0);
597     if (destSpec->g.data == NULL) {
598         LOGE("Failed to allocate g data memory");
599         FreeDsaCommParamsSpec(destSpec);
600         return HCF_ERR_MALLOC;
601     }
602     (void)memcpy_s(destSpec->p.data, srcSpec->p.len, srcSpec->p.data, srcSpec->p.len);
603     (void)memcpy_s(destSpec->q.data, srcSpec->q.len, srcSpec->q.data, srcSpec->q.len);
604     (void)memcpy_s(destSpec->g.data, srcSpec->g.len, srcSpec->g.data, srcSpec->g.len);
605     destSpec->p.len = srcSpec->p.len;
606     destSpec->q.len = srcSpec->q.len;
607     destSpec->g.len = srcSpec->g.len;
608     return HCF_SUCCESS;
609 }
610 
CreateDsaCommonSpecImpl(const HcfDsaCommParamsSpec * srcSpec,HcfDsaCommParamsSpec ** destSpec)611 static HcfResult CreateDsaCommonSpecImpl(const HcfDsaCommParamsSpec *srcSpec, HcfDsaCommParamsSpec **destSpec)
612 {
613     HcfDsaCommParamsSpec *spec = (HcfDsaCommParamsSpec *)HcfMalloc(sizeof(HcfDsaCommParamsSpec), 0);
614     if (spec == NULL) {
615         LOGE("Failed to allocate dest spec memory");
616         return HCF_ERR_MALLOC;
617     }
618 
619     if (CopyDsaCommonSpec(srcSpec, spec) != HCF_SUCCESS) {
620         HcfFree(spec);
621         return HCF_INVALID_PARAMS;
622     }
623 
624     *destSpec = spec;
625     return HCF_SUCCESS;
626 }
627 
CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec * srcSpec,HcfDsaPubKeyParamsSpec ** destSpec)628 static HcfResult CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec *srcSpec, HcfDsaPubKeyParamsSpec **destSpec)
629 {
630     HcfDsaPubKeyParamsSpec *spec = (HcfDsaPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDsaPubKeyParamsSpec), 0);
631     if (spec == NULL) {
632         LOGE("Failed to allocate dest spec memory");
633         return HCF_ERR_MALLOC;
634     }
635     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
636         HcfFree(spec);
637         return HCF_INVALID_PARAMS;
638     }
639     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
640     if (spec->pk.data == NULL) {
641         LOGE("Failed to allocate public key memory");
642         FreeDsaCommParamsSpec(&(spec->base));
643         HcfFree(spec);
644         return HCF_ERR_MALLOC;
645     }
646     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
647     spec->pk.len = srcSpec->pk.len;
648 
649     *destSpec = spec;
650     return HCF_SUCCESS;
651 }
652 
CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec * srcSpec,HcfDsaKeyPairParamsSpec ** destSpec)653 static HcfResult CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec *srcSpec, HcfDsaKeyPairParamsSpec **destSpec)
654 {
655     HcfDsaKeyPairParamsSpec *spec = (HcfDsaKeyPairParamsSpec *)HcfMalloc(sizeof(HcfDsaKeyPairParamsSpec), 0);
656     if (spec == NULL) {
657         LOGE("Failed to allocate dest spec memory");
658         return HCF_ERR_MALLOC;
659     }
660     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
661         HcfFree(spec);
662         return HCF_INVALID_PARAMS;
663     }
664     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
665     if (spec->pk.data == NULL) {
666         LOGE("Failed to allocate public key memory");
667         FreeDsaCommParamsSpec(&(spec->base));
668         HcfFree(spec);
669         return HCF_ERR_MALLOC;
670     }
671     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
672     if (spec->sk.data == NULL) {
673         LOGE("Failed to allocate private key memory");
674         FreeDsaCommParamsSpec(&(spec->base));
675         HcfFree(spec->pk.data);
676         HcfFree(spec);
677         return HCF_ERR_MALLOC;
678     }
679     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
680     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
681     spec->pk.len = srcSpec->pk.len;
682     spec->sk.len = srcSpec->sk.len;
683 
684     *destSpec = spec;
685     return HCF_SUCCESS;
686 }
687 
CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)688 static HcfResult CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
689 {
690     HcfResult ret = HCF_SUCCESS;
691     HcfDsaCommParamsSpec *spec = NULL;
692     switch (paramsSpec->specType) {
693         case HCF_COMMON_PARAMS_SPEC:
694             ret = CreateDsaCommonSpecImpl((HcfDsaCommParamsSpec *)paramsSpec, &spec);
695             break;
696         case HCF_PUBLIC_KEY_SPEC:
697             ret = CreateDsaPubKeySpecImpl((HcfDsaPubKeyParamsSpec *)paramsSpec, (HcfDsaPubKeyParamsSpec **)&spec);
698             break;
699         case HCF_KEY_PAIR_SPEC:
700             ret = CreateDsaKeyPairSpecImpl((HcfDsaKeyPairParamsSpec *)paramsSpec, (HcfDsaKeyPairParamsSpec **)&spec);
701             break;
702         default:
703             ret = HCF_INVALID_PARAMS;
704             break;
705     }
706     if (ret == HCF_SUCCESS) {
707         *impl = (HcfAsyKeyParamsSpec *)spec;
708     }
709     return ret;
710 }
711 
CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec * srcSpec,HcfDhPubKeyParamsSpec ** destSpec)712 static HcfResult CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec *srcSpec, HcfDhPubKeyParamsSpec **destSpec)
713 {
714     HcfDhPubKeyParamsSpec *spec = (HcfDhPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDhPubKeyParamsSpec), 0);
715     if (spec == NULL) {
716         LOGE("Failed to allocate dest spec memory");
717         return HCF_ERR_MALLOC;
718     }
719     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
720         LOGE("Failed to copy src spec");
721         HcfFree(spec);
722         return HCF_INVALID_PARAMS;
723     }
724     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
725     if (spec->pk.data == NULL) {
726         LOGE("Failed to allocate public key memory");
727         DestroyDhPubKeySpec(spec);
728         return HCF_ERR_MALLOC;
729     }
730     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
731     spec->pk.len = srcSpec->pk.len;
732 
733     *destSpec = spec;
734     return HCF_SUCCESS;
735 }
736 
CreateDhPriKeySpecImpl(const HcfDhPriKeyParamsSpec * srcSpec,HcfDhPriKeyParamsSpec ** destSpec)737 static HcfResult CreateDhPriKeySpecImpl(const HcfDhPriKeyParamsSpec *srcSpec, HcfDhPriKeyParamsSpec **destSpec)
738 {
739     HcfDhPriKeyParamsSpec *spec = (HcfDhPriKeyParamsSpec *)HcfMalloc(sizeof(HcfDhPriKeyParamsSpec), 0);
740     if (spec == NULL) {
741         LOGE("Failed to allocate dest spec memory");
742         return HCF_ERR_MALLOC;
743     }
744     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
745         LOGE("Failed to copy src spec");
746         HcfFree(spec);
747         return HCF_INVALID_PARAMS;
748     }
749     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
750     if (spec->sk.data == NULL) {
751         LOGE("Failed to allocate private key memory");
752         FreeDhCommParamsSpec(&(spec->base));
753         HcfFree(spec);
754         return HCF_ERR_MALLOC;
755     }
756     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
757     spec->sk.len = srcSpec->sk.len;
758 
759     *destSpec = spec;
760     return HCF_SUCCESS;
761 }
762 
CreateDhKeyPairSpecImpl(const HcfDhKeyPairParamsSpec * srcSpec,HcfDhKeyPairParamsSpec ** destSpec)763 static HcfResult CreateDhKeyPairSpecImpl(const HcfDhKeyPairParamsSpec *srcSpec, HcfDhKeyPairParamsSpec **destSpec)
764 {
765     HcfDhKeyPairParamsSpec *spec = (HcfDhKeyPairParamsSpec *)HcfMalloc(sizeof(HcfDhKeyPairParamsSpec), 0);
766     if (spec == NULL) {
767         LOGE("Failed to allocate dest spec memory");
768         return HCF_ERR_MALLOC;
769     }
770     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
771         LOGE("Failed to copy src spec");
772         HcfFree(spec);
773         return HCF_INVALID_PARAMS;
774     }
775     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
776     if (spec->pk.data == NULL) {
777         LOGE("Failed to allocate public key memory");
778         FreeDhCommParamsSpec(&(spec->base));
779         HcfFree(spec);
780         return HCF_ERR_MALLOC;
781     }
782     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
783     if (spec->sk.data == NULL) {
784         LOGE("Failed to allocate private key memory");
785         FreeDhCommParamsSpec(&(spec->base));
786         HcfFree(spec->pk.data);
787         HcfFree(spec);
788         return HCF_ERR_MALLOC;
789     }
790     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
791     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
792     spec->pk.len = srcSpec->pk.len;
793     spec->sk.len = srcSpec->sk.len;
794 
795     *destSpec = spec;
796     return HCF_SUCCESS;
797 }
798 
CreateDhParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)799 static HcfResult CreateDhParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
800 {
801     HcfResult ret = HCF_SUCCESS;
802     HcfDhCommParamsSpec *spec = NULL;
803     switch (paramsSpec->specType) {
804         case HCF_COMMON_PARAMS_SPEC:
805             ret = CreateDhCommonSpecImpl((HcfDhCommParamsSpec *)paramsSpec, &spec);
806             break;
807         case HCF_PUBLIC_KEY_SPEC:
808             ret = CreateDhPubKeySpecImpl((HcfDhPubKeyParamsSpec *)paramsSpec, (HcfDhPubKeyParamsSpec **)&spec);
809             break;
810         case HCF_PRIVATE_KEY_SPEC:
811             ret = CreateDhPriKeySpecImpl((HcfDhPriKeyParamsSpec *)paramsSpec, (HcfDhPriKeyParamsSpec **)&spec);
812             break;
813         case HCF_KEY_PAIR_SPEC:
814             ret = CreateDhKeyPairSpecImpl((HcfDhKeyPairParamsSpec *)paramsSpec, (HcfDhKeyPairParamsSpec **)&spec);
815             break;
816         default:
817             LOGE("Invalid spec type [%d]", paramsSpec->specType);
818             ret = HCF_INVALID_PARAMS;
819             break;
820     }
821     if (ret == HCF_SUCCESS) {
822         *impl = (HcfAsyKeyParamsSpec *)spec;
823     }
824     return ret;
825 }
826 
CreateEccPubKeySpecImpl(const HcfEccPubKeyParamsSpec * srcSpec,HcfEccPubKeyParamsSpec ** destSpec)827 static HcfResult CreateEccPubKeySpecImpl(const HcfEccPubKeyParamsSpec *srcSpec, HcfEccPubKeyParamsSpec **destSpec)
828 {
829     HcfEccPubKeyParamsSpec *tmpSpec = (HcfEccPubKeyParamsSpec *)HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0);
830     if (tmpSpec == NULL) {
831         LOGE("Failed to allocate dest spec memory");
832         return HCF_ERR_MALLOC;
833     }
834     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
835         HcfFree(tmpSpec);
836         return HCF_INVALID_PARAMS;
837     }
838     HcfResult res = CopyPoint(&(srcSpec->pk), &(tmpSpec->pk));
839     if (res != HCF_SUCCESS) {
840         LOGE("Failed to allocate public key memory");
841         FreeEccCommParamsSpec(&(tmpSpec->base));
842         HcfFree(tmpSpec);
843         return res;
844     }
845 
846     *destSpec = tmpSpec;
847     return HCF_SUCCESS;
848 }
849 
CreateEccPriKeySpecImpl(const HcfEccPriKeyParamsSpec * srcSpec,HcfEccPriKeyParamsSpec ** destSpec)850 static HcfResult CreateEccPriKeySpecImpl(const HcfEccPriKeyParamsSpec *srcSpec, HcfEccPriKeyParamsSpec **destSpec)
851 {
852     HcfEccPriKeyParamsSpec *tmpSpec = (HcfEccPriKeyParamsSpec *)HcfMalloc(sizeof(HcfEccPriKeyParamsSpec), 0);
853     if (tmpSpec == NULL) {
854         LOGE("Failed to allocate dest spec memory");
855         return HCF_ERR_MALLOC;
856     }
857     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
858         HcfFree(tmpSpec);
859         return HCF_INVALID_PARAMS;
860     }
861     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
862     if (tmpSpec->sk.data == NULL) {
863         LOGE("Failed to allocate private key memory");
864         FreeEccCommParamsSpec(&(tmpSpec->base));
865         HcfFree(tmpSpec);
866         return HCF_ERR_MALLOC;
867     }
868     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
869     tmpSpec->sk.len = srcSpec->sk.len;
870 
871     *destSpec = tmpSpec;
872     return HCF_SUCCESS;
873 }
874 
CreateEccKeyPairSpecImpl(const HcfEccKeyPairParamsSpec * srcSpec,HcfEccKeyPairParamsSpec ** destSpec)875 static HcfResult CreateEccKeyPairSpecImpl(const HcfEccKeyPairParamsSpec *srcSpec, HcfEccKeyPairParamsSpec **destSpec)
876 {
877     HcfEccKeyPairParamsSpec *tmpSpec = (HcfEccKeyPairParamsSpec *)HcfMalloc(sizeof(HcfEccKeyPairParamsSpec), 0);
878     if (tmpSpec == NULL) {
879         LOGE("Failed to allocate dest spec memory");
880         return HCF_ERR_MALLOC;
881     }
882     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
883         HcfFree(tmpSpec);
884         return HCF_INVALID_PARAMS;
885     }
886     HcfResult res = CopyPoint(&(srcSpec->pk), &(tmpSpec->pk));
887     if (res != HCF_SUCCESS) {
888         LOGE("Failed to allocate public key memory");
889         FreeEccCommParamsSpec(&(tmpSpec->base));
890         HcfFree(tmpSpec);
891         return res;
892     }
893     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
894     if (tmpSpec->sk.data == NULL) {
895         LOGE("Failed to allocate private key memory");
896         FreeEccCommParamsSpec(&(tmpSpec->base));
897         HcfFree(tmpSpec->pk.x.data);
898         HcfFree(tmpSpec->pk.y.data);
899         HcfFree(tmpSpec);
900         return HCF_ERR_MALLOC;
901     }
902     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
903     tmpSpec->sk.len = srcSpec->sk.len;
904 
905     *destSpec = tmpSpec;
906     return HCF_SUCCESS;
907 }
908 
CreateEccParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)909 static HcfResult CreateEccParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
910 {
911     HcfResult ret = HCF_SUCCESS;
912     HcfEccCommParamsSpec *spec = NULL;
913     switch (paramsSpec->specType) {
914         case HCF_COMMON_PARAMS_SPEC:
915             ret = CreateEccCommonSpecImpl((HcfEccCommParamsSpec *)paramsSpec, &spec);
916             break;
917         case HCF_PUBLIC_KEY_SPEC:
918             ret = CreateEccPubKeySpecImpl((HcfEccPubKeyParamsSpec *)paramsSpec, (HcfEccPubKeyParamsSpec **)(&spec));
919             break;
920         case HCF_PRIVATE_KEY_SPEC:
921             ret = CreateEccPriKeySpecImpl((HcfEccPriKeyParamsSpec *)paramsSpec, (HcfEccPriKeyParamsSpec **)(&spec));
922             break;
923         case HCF_KEY_PAIR_SPEC:
924             ret = CreateEccKeyPairSpecImpl((HcfEccKeyPairParamsSpec *)paramsSpec, (HcfEccKeyPairParamsSpec **)(&spec));
925             break;
926         default:
927             ret = HCF_INVALID_PARAMS;
928             break;
929     }
930     if (ret == HCF_SUCCESS) {
931         *impl = (HcfAsyKeyParamsSpec *)spec;
932     }
933     return ret;
934 }
935 
CopyRsaCommonSpec(const HcfRsaCommParamsSpec * srcSpec,HcfRsaCommParamsSpec * destSpec)936 static HcfResult CopyRsaCommonSpec(const HcfRsaCommParamsSpec *srcSpec, HcfRsaCommParamsSpec *destSpec)
937 {
938     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
939         return HCF_INVALID_PARAMS;
940     }
941     destSpec->n.data = (unsigned char *)HcfMalloc(srcSpec->n.len, 0);
942     if (destSpec->n.data == NULL) {
943         LOGE("Failed to allocate n data memory");
944         HcfFree(destSpec->base.algName);
945         return HCF_ERR_MALLOC;
946     }
947     (void)memcpy_s(destSpec->n.data, srcSpec->n.len, srcSpec->n.data, srcSpec->n.len);
948     destSpec->n.len = srcSpec->n.len;
949     return HCF_SUCCESS;
950 }
951 
CreateRsaPubKeySpecImpl(const HcfRsaPubKeyParamsSpec * srcSpec,HcfRsaPubKeyParamsSpec ** destSpec)952 static HcfResult CreateRsaPubKeySpecImpl(const HcfRsaPubKeyParamsSpec *srcSpec, HcfRsaPubKeyParamsSpec **destSpec)
953 {
954     HcfRsaPubKeyParamsSpec *spec = (HcfRsaPubKeyParamsSpec *)HcfMalloc(sizeof(HcfRsaPubKeyParamsSpec), 0);
955     if (spec == NULL) {
956         LOGE("Failed to allocate dest spec memory");
957         return HCF_ERR_MALLOC;
958     }
959     if (CopyRsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
960         HcfFree(spec);
961         return HCF_INVALID_PARAMS;
962     }
963     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
964     if (spec->pk.data == NULL) {
965         LOGE("Failed to allocate public key memory");
966         DestroyRsaPubKeySpec(spec);
967         return HCF_ERR_MALLOC;
968     }
969     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
970     spec->pk.len = srcSpec->pk.len;
971 
972     *destSpec = spec;
973     return HCF_SUCCESS;
974 }
975 
CreateRsaKeyPairSpecImpl(const HcfRsaKeyPairParamsSpec * srcSpec,HcfRsaKeyPairParamsSpec ** destSpec)976 static HcfResult CreateRsaKeyPairSpecImpl(const HcfRsaKeyPairParamsSpec *srcSpec, HcfRsaKeyPairParamsSpec **destSpec)
977 {
978     HcfRsaKeyPairParamsSpec *spec = (HcfRsaKeyPairParamsSpec *)HcfMalloc(sizeof(HcfRsaKeyPairParamsSpec), 0);
979     if (spec == NULL) {
980         LOGE("Failed to allocate dest spec memory");
981         return HCF_ERR_MALLOC;
982     }
983     if (CopyRsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
984         HcfFree(spec);
985         return HCF_INVALID_PARAMS;
986     }
987     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
988     if (spec->pk.data == NULL) {
989         LOGE("Failed to allocate public key memory");
990         FreeRsaCommParamsSpec(&(spec->base));
991         HcfFree(spec);
992         return HCF_ERR_MALLOC;
993     }
994     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
995     if (spec->sk.data == NULL) {
996         LOGE("Failed to allocate private key memory");
997         FreeRsaCommParamsSpec(&(spec->base));
998         HcfFree(spec->pk.data);
999         HcfFree(spec);
1000         return HCF_ERR_MALLOC;
1001     }
1002     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1003     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1004     spec->pk.len = srcSpec->pk.len;
1005     spec->sk.len = srcSpec->sk.len;
1006 
1007     *destSpec = spec;
1008     return HCF_SUCCESS;
1009 }
1010 
CreateRsaParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)1011 static HcfResult CreateRsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
1012 {
1013     HcfResult ret = HCF_SUCCESS;
1014     HcfRsaCommParamsSpec *spec = NULL;
1015     switch (paramsSpec->specType) {
1016         // commonspe should not be used in RSA
1017         case HCF_COMMON_PARAMS_SPEC:
1018             LOGE("RSA not support comm spec");
1019             ret = HCF_INVALID_PARAMS;
1020             break;
1021         case HCF_PUBLIC_KEY_SPEC:
1022             ret = CreateRsaPubKeySpecImpl((HcfRsaPubKeyParamsSpec *)paramsSpec, (HcfRsaPubKeyParamsSpec **)&spec);
1023             break;
1024         case HCF_KEY_PAIR_SPEC:
1025             ret = CreateRsaKeyPairSpecImpl((HcfRsaKeyPairParamsSpec *)paramsSpec, (HcfRsaKeyPairParamsSpec **)&spec);
1026             break;
1027         default:
1028             ret = HCF_INVALID_PARAMS;
1029             break;
1030     }
1031     if (ret == HCF_SUCCESS) {
1032         *impl = (HcfAsyKeyParamsSpec *)spec;
1033     }
1034     return ret;
1035 }
1036 
CreateAlg25519PubKeySpecImpl(const HcfAlg25519PubKeyParamsSpec * srcSpec,HcfAlg25519PubKeyParamsSpec ** destSpec)1037 static HcfResult CreateAlg25519PubKeySpecImpl(const HcfAlg25519PubKeyParamsSpec *srcSpec,
1038     HcfAlg25519PubKeyParamsSpec **destSpec)
1039 {
1040     HcfAlg25519PubKeyParamsSpec *tmpSpec =
1041         (HcfAlg25519PubKeyParamsSpec *)HcfMalloc(sizeof(HcfAlg25519PubKeyParamsSpec), 0);
1042     if (tmpSpec == NULL) {
1043         LOGE("Failed to allocate dest spec memory");
1044         return HCF_ERR_MALLOC;
1045     }
1046     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1047         DestroyAlg25519PubKeySpec(tmpSpec);
1048         LOGE("Copy alg25519 commonSpec memory");
1049         return HCF_INVALID_PARAMS;
1050     }
1051     tmpSpec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
1052     if (tmpSpec->pk.data == NULL) {
1053         LOGE("Failed to allocate private key memory");
1054         DestroyAlg25519PubKeySpec(tmpSpec);
1055         return HCF_ERR_MALLOC;
1056     }
1057     (void)memcpy_s(tmpSpec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1058     tmpSpec->pk.len = srcSpec->pk.len;
1059 
1060     *destSpec = tmpSpec;
1061     return HCF_SUCCESS;
1062 }
1063 
CreateAlg25519PriKeySpecImpl(const HcfAlg25519PriKeyParamsSpec * srcSpec,HcfAlg25519PriKeyParamsSpec ** destSpec)1064 static HcfResult CreateAlg25519PriKeySpecImpl(const HcfAlg25519PriKeyParamsSpec *srcSpec,
1065     HcfAlg25519PriKeyParamsSpec **destSpec)
1066 {
1067     HcfAlg25519PriKeyParamsSpec *tmpSpec =
1068         (HcfAlg25519PriKeyParamsSpec *)HcfMalloc(sizeof(HcfAlg25519PriKeyParamsSpec), 0);
1069     if (tmpSpec == NULL) {
1070         LOGE("Failed to allocate dest spec memory");
1071         return HCF_ERR_MALLOC;
1072     }
1073     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1074         DestroyAlg25519PriKeySpec(tmpSpec);
1075         LOGE("Copy alg25519 commonSpec memory");
1076         return HCF_INVALID_PARAMS;
1077     }
1078     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
1079     if (tmpSpec->sk.data == NULL) {
1080         LOGE("Failed to allocate private key memory");
1081         DestroyAlg25519PriKeySpec(tmpSpec);
1082         return HCF_ERR_MALLOC;
1083     }
1084     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1085     tmpSpec->sk.len = srcSpec->sk.len;
1086 
1087     *destSpec = tmpSpec;
1088     return HCF_SUCCESS;
1089 }
1090 
CreateAlg25519KeyPairSpecImpl(const HcfAlg25519KeyPairParamsSpec * srcSpec,HcfAlg25519KeyPairParamsSpec ** destSpec)1091 static HcfResult CreateAlg25519KeyPairSpecImpl(const HcfAlg25519KeyPairParamsSpec *srcSpec,
1092     HcfAlg25519KeyPairParamsSpec **destSpec)
1093 {
1094     HcfAlg25519KeyPairParamsSpec *tmpSpec =
1095         (HcfAlg25519KeyPairParamsSpec *)HcfMalloc(sizeof(HcfAlg25519KeyPairParamsSpec), 0);
1096     if (tmpSpec == NULL) {
1097         LOGE("Failed to allocate dest spec memory");
1098         return HCF_ERR_MALLOC;
1099     }
1100     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1101         DestroyAlg25519KeyPairSpec(tmpSpec);
1102         LOGE("Copy alg25519 commonSpec memory");
1103         return HCF_INVALID_PARAMS;
1104     }
1105     tmpSpec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
1106     if (tmpSpec->pk.data == NULL) {
1107         LOGE("Failed to allocate private key memory");
1108         DestroyAlg25519KeyPairSpec(tmpSpec);
1109         return HCF_ERR_MALLOC;
1110     }
1111 
1112     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
1113     if (tmpSpec->sk.data == NULL) {
1114         LOGE("Failed to allocate private key memory");
1115         DestroyAlg25519KeyPairSpec(tmpSpec);
1116         return HCF_ERR_MALLOC;
1117     }
1118     (void)memcpy_s(tmpSpec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1119     tmpSpec->pk.len = srcSpec->pk.len;
1120     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1121     tmpSpec->sk.len = srcSpec->sk.len;
1122 
1123     *destSpec = tmpSpec;
1124     return HCF_SUCCESS;
1125 }
1126 
CreateAlg25519ParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)1127 static HcfResult CreateAlg25519ParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
1128 {
1129     HcfResult ret = HCF_SUCCESS;
1130     HcfAlg25519PubKeyParamsSpec *pubKeySpec = NULL;
1131     HcfAlg25519PriKeyParamsSpec *priKeySpec = NULL;
1132     HcfAlg25519KeyPairParamsSpec *keyPairSpec = NULL;
1133     switch (paramsSpec->specType) {
1134         case HCF_PUBLIC_KEY_SPEC:
1135             ret = CreateAlg25519PubKeySpecImpl((HcfAlg25519PubKeyParamsSpec *)paramsSpec, &pubKeySpec);
1136             if (ret == HCF_SUCCESS) {
1137                 *impl = (HcfAsyKeyParamsSpec *)pubKeySpec;
1138             }
1139             break;
1140         case HCF_PRIVATE_KEY_SPEC:
1141             ret = CreateAlg25519PriKeySpecImpl((HcfAlg25519PriKeyParamsSpec *)paramsSpec, &priKeySpec);
1142             if (ret == HCF_SUCCESS) {
1143                 *impl = (HcfAsyKeyParamsSpec *)priKeySpec;
1144             }
1145             break;
1146         case HCF_KEY_PAIR_SPEC:
1147             ret = CreateAlg25519KeyPairSpecImpl((HcfAlg25519KeyPairParamsSpec *)paramsSpec, &keyPairSpec);
1148             if (ret == HCF_SUCCESS) {
1149                 *impl = (HcfAsyKeyParamsSpec *)keyPairSpec;
1150             }
1151             break;
1152         default:
1153             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
1154             ret = HCF_INVALID_PARAMS;
1155             break;
1156     }
1157     return ret;
1158 }
1159 
CreateAsyKeyParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAlgValue alg,HcfAsyKeyParamsSpec ** impl)1160 static HcfResult CreateAsyKeyParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAlgValue alg,
1161     HcfAsyKeyParamsSpec **impl)
1162 {
1163     HcfResult ret = HCF_SUCCESS;
1164     switch (alg) {
1165         case HCF_ALG_DSA:
1166             ret = CreateDsaParamsSpecImpl(paramsSpec, impl);
1167             break;
1168         case HCF_ALG_SM2:
1169         case HCF_ALG_ECC:
1170             ret = CreateEccParamsSpecImpl(paramsSpec, impl);
1171             break;
1172         case HCF_ALG_RSA:
1173             ret = CreateRsaParamsSpecImpl(paramsSpec, impl);
1174             break;
1175         case HCF_ALG_ED25519:
1176         case HCF_ALG_X25519:
1177             ret = CreateAlg25519ParamsSpecImpl(paramsSpec, impl);
1178             break;
1179         case HCF_ALG_DH:
1180             ret = CreateDhParamsSpecImpl(paramsSpec, impl);
1181             break;
1182         default:
1183             ret = HCF_INVALID_PARAMS;
1184             break;
1185     }
1186     return ret;
1187 }
1188 
1189 // export interfaces
GetAsyKeyGeneratorClass(void)1190 static const char *GetAsyKeyGeneratorClass(void)
1191 {
1192     return ASY_KEY_GENERATOR_CLASS;
1193 }
1194 
GetAsyKeyGeneratorBySpecClass(void)1195 static const char *GetAsyKeyGeneratorBySpecClass(void)
1196 {
1197     return ASY_KEY_GENERATOR_BY_SPEC_CLASS;
1198 }
1199 
GetAlgoName(HcfAsyKeyGenerator * self)1200 static const char *GetAlgoName(HcfAsyKeyGenerator *self)
1201 {
1202     if (self == NULL) {
1203         LOGE("The input self ptr is NULL!");
1204         return NULL;
1205     }
1206     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1207         return NULL;
1208     }
1209     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1210     return impl->algoName;
1211 }
1212 
GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec * self)1213 static const char *GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec *self)
1214 {
1215     if (self == NULL) {
1216         LOGE("The input self ptr is NULL!");
1217         return NULL;
1218     }
1219     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1220         return NULL;
1221     }
1222     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1223     return impl->paramsSpec->algName;
1224 }
1225 
ConvertKey(HcfAsyKeyGenerator * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)1226 static HcfResult ConvertKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
1227     HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
1228 {
1229     if (self == NULL) {
1230         LOGE("Invalid input parameter.");
1231         return HCF_INVALID_PARAMS;
1232     }
1233     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1234         return HCF_INVALID_PARAMS;
1235     }
1236     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1237     if (impl->spiObj == NULL || impl->spiObj->engineConvertKey == NULL) {
1238         LOGE("Invalid input parameter.");
1239         return HCF_INVALID_PARAMS;
1240     }
1241     return impl->spiObj->engineConvertKey(impl->spiObj, params, pubKeyBlob, priKeyBlob, returnKeyPair);
1242 }
1243 
ConvertPemKey(HcfAsyKeyGenerator * self,HcfParamsSpec * params,const char * pubKeyStr,const char * priKeyStr,HcfKeyPair ** returnKeyPair)1244 static HcfResult ConvertPemKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, const char *pubKeyStr,
1245     const char *priKeyStr, HcfKeyPair **returnKeyPair)
1246 {
1247     if (self == NULL) {
1248         LOGE("Invalid input parameter.");
1249         return HCF_INVALID_PARAMS;
1250     }
1251     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1252         return HCF_INVALID_PARAMS;
1253     }
1254     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1255     if (impl->spiObj == NULL || impl->spiObj->engineConvertPemKey == NULL) {
1256         LOGE("Invalid input parameter.");
1257         return HCF_INVALID_PARAMS;
1258     }
1259     return impl->spiObj->engineConvertPemKey(impl->spiObj, params, pubKeyStr, priKeyStr, returnKeyPair);
1260 }
1261 
GenerateKeyPair(HcfAsyKeyGenerator * self,HcfParamsSpec * params,HcfKeyPair ** returnKeyPair)1262 static HcfResult GenerateKeyPair(HcfAsyKeyGenerator *self, HcfParamsSpec *params,
1263     HcfKeyPair **returnKeyPair)
1264 {
1265     (void)params;
1266     if (self == NULL) {
1267         LOGE("Invalid input parameter.");
1268         return HCF_INVALID_PARAMS;
1269     }
1270     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1271         return HCF_INVALID_PARAMS;
1272     }
1273     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1274     if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPair == NULL) {
1275         LOGE("Invalid input parameter.");
1276         return HCF_INVALID_PARAMS;
1277     }
1278     return impl->spiObj->engineGenerateKeyPair(impl->spiObj, returnKeyPair);
1279 }
1280 
GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfKeyPair ** returnKeyPair)1281 static HcfResult GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfKeyPair **returnKeyPair)
1282 {
1283     if (self == NULL) {
1284         LOGE("Invalid input parameter.");
1285         return HCF_INVALID_PARAMS;
1286     }
1287     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1288         return HCF_INVALID_PARAMS;
1289     }
1290     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1291     if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPairBySpec == NULL) {
1292         LOGE("Invalid input parameter.");
1293         return HCF_INVALID_PARAMS;
1294     }
1295     return impl->spiObj->engineGenerateKeyPairBySpec(impl->spiObj, impl->paramsSpec, returnKeyPair);
1296 }
1297 
GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPubKey ** returnPubKey)1298 static HcfResult GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPubKey **returnPubKey)
1299 {
1300     if (self == NULL) {
1301         LOGE("Invalid input parameter.");
1302         return HCF_INVALID_PARAMS;
1303     }
1304     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1305         return HCF_INVALID_PARAMS;
1306     }
1307     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1308     if (impl->spiObj == NULL || impl->spiObj->engineGeneratePubKeyBySpec == NULL) {
1309         LOGE("Invalid input parameter.");
1310         return HCF_INVALID_PARAMS;
1311     }
1312     return impl->spiObj->engineGeneratePubKeyBySpec(impl->spiObj, impl->paramsSpec, returnPubKey);
1313 }
1314 
GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPriKey ** returnPriKey)1315 static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPriKey **returnPriKey)
1316 {
1317     if (self == NULL) {
1318         LOGE("Invalid input parameter.");
1319         return HCF_INVALID_PARAMS;
1320     }
1321     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1322         return HCF_INVALID_PARAMS;
1323     }
1324     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1325     if (impl->spiObj == NULL || impl->spiObj->engineGeneratePriKeyBySpec == NULL) {
1326         LOGE("Invalid input parameter.");
1327         return HCF_INVALID_PARAMS;
1328     }
1329     return impl->spiObj->engineGeneratePriKeyBySpec(impl->spiObj, impl->paramsSpec, returnPriKey);
1330 }
1331 
DestroyAsyKeyGenerator(HcfObjectBase * self)1332 static void DestroyAsyKeyGenerator(HcfObjectBase *self)
1333 {
1334     if (self == NULL) {
1335         return;
1336     }
1337     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1338         return;
1339     }
1340     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1341     HcfObjDestroy(impl->spiObj);
1342     impl->spiObj = NULL;
1343     HcfFree(impl);
1344 }
1345 
DestroyAsyKeyGeneratorBySpec(HcfObjectBase * self)1346 static void DestroyAsyKeyGeneratorBySpec(HcfObjectBase *self)
1347 {
1348     if (self == NULL) {
1349         return;
1350     }
1351     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1352         return;
1353     }
1354     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1355     HcfObjDestroy(impl->spiObj);
1356     impl->spiObj = NULL;
1357     FreeAsyKeySpec(impl->paramsSpec);
1358     impl->paramsSpec = NULL;
1359     HcfFree(impl);
1360 }
1361 
HcfAsyKeyGeneratorCreate(const char * algoName,HcfAsyKeyGenerator ** returnObj)1362 HcfResult HcfAsyKeyGeneratorCreate(const char *algoName, HcfAsyKeyGenerator **returnObj)
1363 {
1364     if ((!HcfIsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) {
1365         return HCF_INVALID_PARAMS;
1366     }
1367 
1368     HcfAsyKeyGenParams params = { 0 };
1369     if (ParseAndSetParameter(algoName, &params, ParseAsyKeyGenParams) != HCF_SUCCESS) {
1370         LOGE("Failed to parse params!");
1371         return HCF_INVALID_PARAMS;
1372     }
1373 
1374     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1375     if (createSpiFunc == NULL) {
1376         return HCF_NOT_SUPPORT;
1377     }
1378 
1379     HcfAsyKeyGeneratorImpl *returnGenerator = (HcfAsyKeyGeneratorImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorImpl), 0);
1380     if (returnGenerator == NULL) {
1381         LOGE("Failed to allocate returnGenerator memory!");
1382         return HCF_ERR_MALLOC;
1383     }
1384     if (strcpy_s(returnGenerator->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) {
1385         LOGE("Failed to copy algoName!");
1386         HcfFree(returnGenerator);
1387         return HCF_INVALID_PARAMS;
1388     }
1389     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1390     HcfResult res = HCF_SUCCESS;
1391     res = createSpiFunc(&params, &spiObj);
1392     if (res != HCF_SUCCESS) {
1393         LOGE("Failed to create spi object!");
1394         HcfFree(returnGenerator);
1395         return res;
1396     }
1397     returnGenerator->base.base.destroy = DestroyAsyKeyGenerator;
1398     returnGenerator->base.base.getClass = GetAsyKeyGeneratorClass;
1399     returnGenerator->base.convertKey = ConvertKey;
1400     returnGenerator->base.convertPemKey = ConvertPemKey;
1401     returnGenerator->base.generateKeyPair = GenerateKeyPair;
1402     returnGenerator->base.getAlgoName = GetAlgoName;
1403     returnGenerator->spiObj = spiObj;
1404     *returnObj = (HcfAsyKeyGenerator *)returnGenerator;
1405     return HCF_SUCCESS;
1406 }
1407 
HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyGeneratorBySpec ** returnObj)1408 HcfResult HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyGeneratorBySpec **returnObj)
1409 {
1410     if ((!IsParamsSpecValid(paramsSpec)) || (returnObj == NULL)) {
1411         return HCF_INVALID_PARAMS;
1412     }
1413     HcfAsyKeyGenParams params = { 0 };
1414     if (ParseAlgNameToParams(paramsSpec->algName, &params) != HCF_SUCCESS) {
1415         LOGE("Failed to parse params!");
1416         return HCF_INVALID_PARAMS;
1417     }
1418     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1419     if (createSpiFunc == NULL) {
1420         return HCF_NOT_SUPPORT;
1421     }
1422     HcfAsyKeyGeneratorBySpecImpl *returnGenerator =
1423         (HcfAsyKeyGeneratorBySpecImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorBySpecImpl), 0);
1424     if (returnGenerator == NULL) {
1425         LOGE("Failed to allocate returnGenerator memory!");
1426         return HCF_ERR_MALLOC;
1427     }
1428     HcfAsyKeyParamsSpec *paramsSpecImpl = NULL;
1429     HcfResult ret = CreateAsyKeyParamsSpecImpl(paramsSpec, params.algo, &paramsSpecImpl);
1430     if (ret != HCF_SUCCESS) {
1431         LOGE("Failed to create asy key params spec impl!");
1432         HcfFree(returnGenerator);
1433         return ret;
1434     }
1435     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1436     ret = createSpiFunc(&params, &spiObj);
1437     if (ret != HCF_SUCCESS) {
1438         LOGE("Failed to create spi object!");
1439         HcfFree(returnGenerator);
1440         FreeAsyKeySpec(paramsSpecImpl);
1441         return ret;
1442     }
1443     returnGenerator->base.base.destroy = DestroyAsyKeyGeneratorBySpec;
1444     returnGenerator->base.base.getClass = GetAsyKeyGeneratorBySpecClass;
1445     returnGenerator->base.generateKeyPair = GenerateKeyPairBySpec;
1446     returnGenerator->base.generatePubKey = GeneratePubKeyBySpec;
1447     returnGenerator->base.generatePriKey = GeneratePriKeyBySpec;
1448     returnGenerator->base.getAlgName = GetAlgNameBySpec;
1449     returnGenerator->paramsSpec = paramsSpecImpl;
1450     returnGenerator->spiObj = spiObj;
1451     *returnObj = (HcfAsyKeyGeneratorBySpec *)returnGenerator;
1452     return HCF_SUCCESS;
1453 }