• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "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_ED25519_256, HCF_ALG_ED25519_256, HCF_ALG_ED25519 },
121     { HCF_ALG_X25519_256, HCF_ALG_X25519_256, HCF_ALG_X25519 },
122     { HCF_OPENSSL_DH_MODP_1536, HCF_DH_MODP_SIZE_1536, HCF_ALG_DH },
123     { HCF_OPENSSL_DH_MODP_2048, HCF_DH_MODP_SIZE_2048, HCF_ALG_DH },
124     { HCF_OPENSSL_DH_MODP_3072, HCF_DH_MODP_SIZE_3072, HCF_ALG_DH },
125     { HCF_OPENSSL_DH_MODP_4096, HCF_DH_MODP_SIZE_4096, HCF_ALG_DH },
126     { HCF_OPENSSL_DH_MODP_6144, HCF_DH_MODP_SIZE_6144, HCF_ALG_DH },
127     { HCF_OPENSSL_DH_MODP_8192, HCF_DH_MODP_SIZE_8192, HCF_ALG_DH },
128     { HCF_OPENSSL_DH_FFDHE_2048, HCF_DH_FFDHE_SIZE_2048, HCF_ALG_DH },
129     { HCF_OPENSSL_DH_FFDHE_3072, HCF_DH_FFDHE_SIZE_3072, HCF_ALG_DH },
130     { HCF_OPENSSL_DH_FFDHE_4096, HCF_DH_FFDHE_SIZE_4096, HCF_ALG_DH },
131     { HCF_OPENSSL_DH_FFDHE_6144, HCF_DH_FFDHE_SIZE_6144, HCF_ALG_DH },
132     { HCF_OPENSSL_DH_FFDHE_8192, HCF_DH_FFDHE_SIZE_8192, HCF_ALG_DH }
133 };
IsDsaCommParamsSpecValid(HcfDsaCommParamsSpec * paramsSpec)134 static bool IsDsaCommParamsSpecValid(HcfDsaCommParamsSpec *paramsSpec)
135 {
136     if ((paramsSpec->p.data == NULL) || (paramsSpec->p.len == 0)) {
137         LOGE("BigInteger p is invalid");
138         return false;
139     }
140     if ((paramsSpec->q.data == NULL) || (paramsSpec->q.len == 0)) {
141         LOGE("BigInteger q is invalid");
142         return false;
143     }
144     if ((paramsSpec->g.data == NULL) || (paramsSpec->g.len == 0)) {
145         LOGE("BigInteger g is invalid");
146         return false;
147     }
148     return true;
149 }
150 
IsDsaPubKeySpecValid(HcfDsaPubKeyParamsSpec * paramsSpec)151 static bool IsDsaPubKeySpecValid(HcfDsaPubKeyParamsSpec *paramsSpec)
152 {
153     if (!IsDsaCommParamsSpecValid(&(paramsSpec->base))) {
154         return false;
155     }
156     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
157         LOGE("BigInteger pk is invalid");
158         return false;
159     }
160     return true;
161 }
162 
IsDsaKeyPairSpecValid(HcfDsaKeyPairParamsSpec * paramsSpec)163 static bool IsDsaKeyPairSpecValid(HcfDsaKeyPairParamsSpec *paramsSpec)
164 {
165     if (!IsDsaCommParamsSpecValid(&(paramsSpec->base))) {
166         return false;
167     }
168     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
169         LOGE("BigInteger pk is invalid");
170         return false;
171     }
172     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
173         LOGE("BigInteger sk is invalid");
174         return false;
175     }
176     return true;
177 }
178 
IsDsaParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)179 static bool IsDsaParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
180 {
181     bool ret = false;
182     switch (paramsSpec->specType) {
183         case HCF_COMMON_PARAMS_SPEC:
184             ret = IsDsaCommParamsSpecValid((HcfDsaCommParamsSpec *)paramsSpec);
185             break;
186         case HCF_PUBLIC_KEY_SPEC:
187             ret = IsDsaPubKeySpecValid((HcfDsaPubKeyParamsSpec *)paramsSpec);
188             break;
189         case HCF_KEY_PAIR_SPEC:
190             ret = IsDsaKeyPairSpecValid((HcfDsaKeyPairParamsSpec *)paramsSpec);
191             break;
192         default:
193             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
194             break;
195     }
196     return ret;
197 }
198 
IsDhCommParamsSpecValid(HcfDhCommParamsSpec * paramsSpec)199 static bool IsDhCommParamsSpecValid(HcfDhCommParamsSpec *paramsSpec)
200 {
201     if ((paramsSpec->p.data == NULL) || (paramsSpec->p.len == 0)) {
202         LOGE("BigInteger p is invalid");
203         return false;
204     }
205     if ((paramsSpec->g.data == NULL) || (paramsSpec->g.len == 0)) {
206         LOGE("BigInteger g is invalid");
207         return false;
208     }
209     return true;
210 }
211 
IsDhPriKeySpecValid(HcfDhPriKeyParamsSpec * paramsSpec)212 static bool IsDhPriKeySpecValid(HcfDhPriKeyParamsSpec *paramsSpec)
213 {
214     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
215         return false;
216     }
217     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
218         LOGE("BigInteger sk is invalid");
219         return false;
220     }
221     return true;
222 }
223 
IsDhPubKeySpecValid(HcfDhPubKeyParamsSpec * paramsSpec)224 static bool IsDhPubKeySpecValid(HcfDhPubKeyParamsSpec *paramsSpec)
225 {
226     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
227         return false;
228     }
229     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
230         LOGE("BigInteger pk is invalid");
231         return false;
232     }
233     return true;
234 }
235 
IsDhKeyPairSpecValid(HcfDhKeyPairParamsSpec * paramsSpec)236 static bool IsDhKeyPairSpecValid(HcfDhKeyPairParamsSpec *paramsSpec)
237 {
238     if (!IsDhCommParamsSpecValid(&(paramsSpec->base))) {
239         return false;
240     }
241     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
242         LOGE("BigInteger pk is invalid");
243         return false;
244     }
245     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
246         LOGE("BigInteger sk is invalid");
247         return false;
248     }
249     return true;
250 }
251 
IsDhParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)252 static bool IsDhParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
253 {
254     bool ret = false;
255     switch (paramsSpec->specType) {
256         case HCF_COMMON_PARAMS_SPEC:
257             ret = IsDhCommParamsSpecValid((HcfDhCommParamsSpec *)paramsSpec);
258             break;
259         case HCF_PRIVATE_KEY_SPEC:
260             ret = IsDhPriKeySpecValid((HcfDhPriKeyParamsSpec *)paramsSpec);
261             break;
262         case HCF_PUBLIC_KEY_SPEC:
263             ret = IsDhPubKeySpecValid((HcfDhPubKeyParamsSpec *)paramsSpec);
264             break;
265         case HCF_KEY_PAIR_SPEC:
266             ret = IsDhKeyPairSpecValid((HcfDhKeyPairParamsSpec *)paramsSpec);
267             break;
268         default:
269             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
270             break;
271     }
272     return ret;
273 }
274 
IsEccCommParamsSpecValid(HcfEccCommParamsSpec * paramsSpec)275 static bool IsEccCommParamsSpecValid(HcfEccCommParamsSpec *paramsSpec)
276 {
277     if ((paramsSpec->a.data == NULL) || (paramsSpec->a.len == 0)) {
278         LOGE("BigInteger a is invalid");
279         return false;
280     }
281     if ((paramsSpec->b.data == NULL) || (paramsSpec->b.len == 0)) {
282         LOGE("BigInteger b is invalid");
283         return false;
284     }
285     if ((paramsSpec->n.data == NULL) || (paramsSpec->n.len == 0)) {
286         LOGE("BigInteger n is invalid");
287         return false;
288     }
289     if ((paramsSpec->g.x.data == NULL) || (paramsSpec->g.x.len == 0) ||
290         (paramsSpec->g.y.data == NULL) || (paramsSpec->g.y.len == 0)) {
291         LOGE("Point g is invalid");
292         return false;
293     }
294     if (paramsSpec->field == NULL) {
295         LOGE("Field is null.");
296         return false;
297     }
298     if (strcmp(paramsSpec->field->fieldType, "Fp") != 0) {
299         LOGE("Unknown field type.");
300         return false;
301     }
302     HcfECFieldFp *tmp = (HcfECFieldFp *)(paramsSpec->field);
303     if ((tmp->p.data == NULL) || (tmp->p.len == 0)) {
304         LOGE("EcFieldFp p is invalid");
305         return false;
306     }
307     return true;
308 }
309 
IsEccPriKeySpecValid(HcfEccPriKeyParamsSpec * paramsSpec)310 static bool IsEccPriKeySpecValid(HcfEccPriKeyParamsSpec *paramsSpec)
311 {
312     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
313         return false;
314     }
315     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
316         LOGE("BigInteger sk is invalid");
317         return false;
318     }
319     return true;
320 }
321 
IsEccPubKeySpecValid(HcfEccPubKeyParamsSpec * paramsSpec)322 static bool IsEccPubKeySpecValid(HcfEccPubKeyParamsSpec *paramsSpec)
323 {
324     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
325         return false;
326     }
327     if ((paramsSpec->pk.x.data == NULL) || (paramsSpec->pk.x.len == 0) ||
328         (paramsSpec->pk.y.data == NULL) || (paramsSpec->pk.y.len == 0)) {
329         LOGE("Point pk is invalid");
330         return false;
331     }
332     return true;
333 }
334 
IsEccKeyPairSpecValid(HcfEccKeyPairParamsSpec * paramsSpec)335 static bool IsEccKeyPairSpecValid(HcfEccKeyPairParamsSpec *paramsSpec)
336 {
337     if (!IsEccCommParamsSpecValid(&(paramsSpec->base))) {
338         return false;
339     }
340     if ((paramsSpec->pk.x.data == NULL) || (paramsSpec->pk.x.len == 0) ||
341         (paramsSpec->pk.y.data == NULL) || (paramsSpec->pk.y.len == 0)) {
342         LOGE("Point pk is invalid");
343         return false;
344     }
345     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
346         LOGE("BigInteger sk is invalid");
347         return false;
348     }
349     return true;
350 }
351 
IsEccParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)352 static bool IsEccParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
353 {
354     bool ret = false;
355     switch (paramsSpec->specType) {
356         case HCF_COMMON_PARAMS_SPEC:
357             ret = IsEccCommParamsSpecValid((HcfEccCommParamsSpec *)paramsSpec);
358             break;
359         case HCF_PRIVATE_KEY_SPEC:
360             ret = IsEccPriKeySpecValid((HcfEccPriKeyParamsSpec *)paramsSpec);
361             break;
362         case HCF_PUBLIC_KEY_SPEC:
363             ret = IsEccPubKeySpecValid((HcfEccPubKeyParamsSpec *)paramsSpec);
364             break;
365         case HCF_KEY_PAIR_SPEC:
366             ret = IsEccKeyPairSpecValid((HcfEccKeyPairParamsSpec *)paramsSpec);
367             break;
368         default:
369             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
370             break;
371     }
372     return ret;
373 }
374 
IsAlg25519PriKeySpecValid(HcfAlg25519PriKeyParamsSpec * paramsSpec)375 static bool IsAlg25519PriKeySpecValid(HcfAlg25519PriKeyParamsSpec *paramsSpec)
376 {
377     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
378         LOGE("Uint8Array sk is invalid");
379         return false;
380     }
381     return true;
382 }
383 
IsAlg25519PubKeySpecValid(HcfAlg25519PubKeyParamsSpec * paramsSpec)384 static bool IsAlg25519PubKeySpecValid(HcfAlg25519PubKeyParamsSpec *paramsSpec)
385 {
386     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
387         LOGE("Uint8Array pk is invalid");
388         return false;
389     }
390     return true;
391 }
392 
IsAlg25519KeyPairSpecValid(HcfAlg25519KeyPairParamsSpec * paramsSpec)393 static bool IsAlg25519KeyPairSpecValid(HcfAlg25519KeyPairParamsSpec *paramsSpec)
394 {
395     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
396         LOGE("Uint8Array pk is invalid");
397         return false;
398     }
399     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
400         LOGE("Uint8Array sk is invalid");
401         return false;
402     }
403     return true;
404 }
405 
IsAlg25519ParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)406 static bool IsAlg25519ParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
407 {
408     bool ret = false;
409     switch (paramsSpec->specType) {
410         case HCF_PRIVATE_KEY_SPEC:
411             ret = IsAlg25519PriKeySpecValid((HcfAlg25519PriKeyParamsSpec *)paramsSpec);
412             break;
413         case HCF_PUBLIC_KEY_SPEC:
414             ret = IsAlg25519PubKeySpecValid((HcfAlg25519PubKeyParamsSpec *)paramsSpec);
415             break;
416         case HCF_KEY_PAIR_SPEC:
417             ret = IsAlg25519KeyPairSpecValid((HcfAlg25519KeyPairParamsSpec *)paramsSpec);
418             break;
419         default:
420             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
421             break;
422     }
423     return ret;
424 }
425 
IsRsaCommParamsSpecValid(HcfRsaCommParamsSpec * paramsSpec)426 static bool IsRsaCommParamsSpecValid(HcfRsaCommParamsSpec *paramsSpec)
427 {
428     if ((paramsSpec->n.data == NULL) || (paramsSpec->n.len == 0)) {
429         LOGE("BigInteger n is invalid");
430         return false;
431     }
432     return true;
433 }
434 
IsRsaPubKeySpecValid(HcfRsaPubKeyParamsSpec * paramsSpec)435 static bool IsRsaPubKeySpecValid(HcfRsaPubKeyParamsSpec *paramsSpec)
436 {
437     if (!IsRsaCommParamsSpecValid(&(paramsSpec->base))) {
438         return false;
439     }
440     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
441         LOGE("BigInteger pk is invalid");
442         return false;
443     }
444     return true;
445 }
446 
IsRsaKeyPairSpecValid(HcfRsaKeyPairParamsSpec * paramsSpec)447 static bool IsRsaKeyPairSpecValid(HcfRsaKeyPairParamsSpec *paramsSpec)
448 {
449     if (!IsRsaCommParamsSpecValid(&(paramsSpec->base))) {
450         return false;
451     }
452     if ((paramsSpec->pk.data == NULL) || (paramsSpec->pk.len == 0)) {
453         LOGE("BigInteger pk is invalid");
454         return false;
455     }
456     if ((paramsSpec->sk.data == NULL) || (paramsSpec->sk.len == 0)) {
457         LOGE("BigInteger sk is invalid");
458         return false;
459     }
460     return true;
461 }
462 
IsRsaParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)463 static bool IsRsaParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
464 {
465     bool ret = false;
466     switch (paramsSpec->specType) {
467         case HCF_COMMON_PARAMS_SPEC:
468             ret = IsRsaCommParamsSpecValid((HcfRsaCommParamsSpec *)paramsSpec);
469             break;
470         case HCF_PUBLIC_KEY_SPEC:
471             ret = IsRsaPubKeySpecValid((HcfRsaPubKeyParamsSpec *)paramsSpec);
472             break;
473         case HCF_KEY_PAIR_SPEC:
474             ret = IsRsaKeyPairSpecValid((HcfRsaKeyPairParamsSpec *)paramsSpec);
475             break;
476         default:
477             LOGE("SpecType not support! [SpecType]: %d", paramsSpec->specType);
478             break;
479     }
480     return ret;
481 }
482 
IsParamsSpecValid(const HcfAsyKeyParamsSpec * paramsSpec)483 static bool IsParamsSpecValid(const HcfAsyKeyParamsSpec *paramsSpec)
484 {
485     if ((paramsSpec == NULL) || (paramsSpec->algName == NULL)) {
486         LOGE("Params spec is null");
487         return false;
488     }
489     if (strcmp(paramsSpec->algName, ALG_NAME_DSA) == 0) {
490         return IsDsaParamsSpecValid(paramsSpec);
491     } else if (strcmp(paramsSpec->algName, ALG_NAME_ECC) == 0 || strcmp(paramsSpec->algName, ALG_NAME_SM2) == 0) {
492         return IsEccParamsSpecValid(paramsSpec);
493     } else if (strcmp(paramsSpec->algName, ALG_NAME_RSA) == 0) {
494         return IsRsaParamsSpecValid(paramsSpec);
495     } else if (strcmp(paramsSpec->algName, ALG_NAME_X25519) == 0 ||
496         strcmp(paramsSpec->algName, ALG_NAME_ED25519) == 0) {
497         return IsAlg25519ParamsSpecValid(paramsSpec);
498     } else if (strcmp(paramsSpec->algName, ALG_NAME_DH) == 0) {
499         return IsDhParamsSpecValid(paramsSpec);
500     } else {
501         LOGE("AlgName not support! [AlgName]: %s", paramsSpec->algName);
502         return false;
503     }
504 }
505 
FindAbility(HcfAsyKeyGenParams * params)506 static HcfAsyKeyGeneratorSpiCreateFunc FindAbility(HcfAsyKeyGenParams *params)
507 {
508     for (uint32_t i = 0; i < sizeof(ASY_KEY_GEN_ABILITY_SET) / sizeof(ASY_KEY_GEN_ABILITY_SET[0]); i++) {
509         if (ASY_KEY_GEN_ABILITY_SET[i].algo == params->algo) {
510             return ASY_KEY_GEN_ABILITY_SET[i].createSpiFunc;
511         }
512     }
513     LOGE("Algo not support! [Algo]: %d", params->algo);
514     return NULL;
515 }
516 
SetPrimes(HcfAlgParaValue value,HcfAsyKeyGenParams * params)517 static void SetPrimes(HcfAlgParaValue value, HcfAsyKeyGenParams *params)
518 {
519     if (params == NULL) {
520         LOGE("params is null.");
521         return;
522     }
523     switch (value) {
524         case HCF_OPENSSL_PRIMES_2:
525             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_2;
526             break;
527         case HCF_OPENSSL_PRIMES_3:
528             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_3;
529             break;
530         case HCF_OPENSSL_PRIMES_4:
531             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_4;
532             break;
533         case HCF_OPENSSL_PRIMES_5:
534             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_5;
535             break;
536         default:
537             params->primes = (int32_t)HCF_RSA_PRIMES_SIZE_2; // default primes is 2
538             LOGD("user default primes 2");
539             break;
540     }
541     LOGD("Set primes:%d!", params->primes);
542 }
543 
SetKeyType(HcfAlgParaValue value,HcfAsyKeyGenParams * params)544 static void SetKeyType(HcfAlgParaValue value, HcfAsyKeyGenParams *params)
545 {
546     for (uint32_t i = 0; i < sizeof(KEY_TYPE_MAP) / sizeof(KEY_TYPE_MAP[0]); i++) {
547         if (KEY_TYPE_MAP[i].value == value) {
548             params->bits = KEY_TYPE_MAP[i].bits;
549             params->algo = KEY_TYPE_MAP[i].algo;
550             return;
551         }
552     }
553     LOGE("There is not matched algorithm.");
554 }
555 
ParseAsyKeyGenParams(const HcfParaConfig * config,void * params)556 static HcfResult ParseAsyKeyGenParams(const HcfParaConfig* config, void *params)
557 {
558     if (config == NULL || params == NULL) {
559         return HCF_INVALID_PARAMS;
560     }
561     HcfResult ret = HCF_SUCCESS;
562     HcfAsyKeyGenParams *paramsObj = (HcfAsyKeyGenParams *)params;
563     LOGD("Set Parameter: %s", config->tag);
564     switch (config->paraType) {
565         case HCF_ALG_KEY_TYPE:
566             SetKeyType(config->paraValue, paramsObj);
567             break;
568         case HCF_ALG_PRIMES:
569             SetPrimes(config->paraValue, paramsObj);
570             break;
571         default:
572             ret = HCF_INVALID_PARAMS;
573             break;
574     }
575     return ret;
576 }
577 
CopyDsaCommonSpec(const HcfDsaCommParamsSpec * srcSpec,HcfDsaCommParamsSpec * destSpec)578 static HcfResult CopyDsaCommonSpec(const HcfDsaCommParamsSpec *srcSpec, HcfDsaCommParamsSpec *destSpec)
579 {
580     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
581         return HCF_INVALID_PARAMS;
582     }
583     destSpec->p.data = (unsigned char *)HcfMalloc(srcSpec->p.len, 0);
584     if (destSpec->p.data == NULL) {
585         LOGE("Failed to allocate p data memory");
586         FreeDsaCommParamsSpec(destSpec);
587         return HCF_ERR_MALLOC;
588     }
589     destSpec->q.data = (unsigned char *)HcfMalloc(srcSpec->q.len, 0);
590     if (destSpec->q.data == NULL) {
591         LOGE("Failed to allocate q data memory");
592         FreeDsaCommParamsSpec(destSpec);
593         return HCF_ERR_MALLOC;
594     }
595     destSpec->g.data = (unsigned char *)HcfMalloc(srcSpec->g.len, 0);
596     if (destSpec->g.data == NULL) {
597         LOGE("Failed to allocate g data memory");
598         FreeDsaCommParamsSpec(destSpec);
599         return HCF_ERR_MALLOC;
600     }
601     (void)memcpy_s(destSpec->p.data, srcSpec->p.len, srcSpec->p.data, srcSpec->p.len);
602     (void)memcpy_s(destSpec->q.data, srcSpec->q.len, srcSpec->q.data, srcSpec->q.len);
603     (void)memcpy_s(destSpec->g.data, srcSpec->g.len, srcSpec->g.data, srcSpec->g.len);
604     destSpec->p.len = srcSpec->p.len;
605     destSpec->q.len = srcSpec->q.len;
606     destSpec->g.len = srcSpec->g.len;
607     return HCF_SUCCESS;
608 }
609 
CreateDsaCommonSpecImpl(const HcfDsaCommParamsSpec * srcSpec,HcfDsaCommParamsSpec ** destSpec)610 static HcfResult CreateDsaCommonSpecImpl(const HcfDsaCommParamsSpec *srcSpec, HcfDsaCommParamsSpec **destSpec)
611 {
612     HcfDsaCommParamsSpec *spec = (HcfDsaCommParamsSpec *)HcfMalloc(sizeof(HcfDsaCommParamsSpec), 0);
613     if (spec == NULL) {
614         LOGE("Failed to allocate dest spec memory");
615         return HCF_ERR_MALLOC;
616     }
617 
618     if (CopyDsaCommonSpec(srcSpec, spec) != HCF_SUCCESS) {
619         HcfFree(spec);
620         return HCF_INVALID_PARAMS;
621     }
622 
623     *destSpec = spec;
624     return HCF_SUCCESS;
625 }
626 
CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec * srcSpec,HcfDsaPubKeyParamsSpec ** destSpec)627 static HcfResult CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec *srcSpec, HcfDsaPubKeyParamsSpec **destSpec)
628 {
629     HcfDsaPubKeyParamsSpec *spec = (HcfDsaPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDsaPubKeyParamsSpec), 0);
630     if (spec == NULL) {
631         LOGE("Failed to allocate dest spec memory");
632         return HCF_ERR_MALLOC;
633     }
634     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
635         HcfFree(spec);
636         return HCF_INVALID_PARAMS;
637     }
638     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
639     if (spec->pk.data == NULL) {
640         LOGE("Failed to allocate public key memory");
641         FreeDsaCommParamsSpec(&(spec->base));
642         HcfFree(spec);
643         return HCF_ERR_MALLOC;
644     }
645     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
646     spec->pk.len = srcSpec->pk.len;
647 
648     *destSpec = spec;
649     return HCF_SUCCESS;
650 }
651 
CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec * srcSpec,HcfDsaKeyPairParamsSpec ** destSpec)652 static HcfResult CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec *srcSpec, HcfDsaKeyPairParamsSpec **destSpec)
653 {
654     HcfDsaKeyPairParamsSpec *spec = (HcfDsaKeyPairParamsSpec *)HcfMalloc(sizeof(HcfDsaKeyPairParamsSpec), 0);
655     if (spec == NULL) {
656         LOGE("Failed to allocate dest spec memory");
657         return HCF_ERR_MALLOC;
658     }
659     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
660         HcfFree(spec);
661         return HCF_INVALID_PARAMS;
662     }
663     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
664     if (spec->pk.data == NULL) {
665         LOGE("Failed to allocate public key memory");
666         FreeDsaCommParamsSpec(&(spec->base));
667         HcfFree(spec);
668         return HCF_ERR_MALLOC;
669     }
670     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
671     if (spec->sk.data == NULL) {
672         LOGE("Failed to allocate private key memory");
673         FreeDsaCommParamsSpec(&(spec->base));
674         HcfFree(spec->pk.data);
675         HcfFree(spec);
676         return HCF_ERR_MALLOC;
677     }
678     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
679     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
680     spec->pk.len = srcSpec->pk.len;
681     spec->sk.len = srcSpec->sk.len;
682 
683     *destSpec = spec;
684     return HCF_SUCCESS;
685 }
686 
CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)687 static HcfResult CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
688 {
689     HcfResult ret = HCF_SUCCESS;
690     HcfDsaCommParamsSpec *spec = NULL;
691     switch (paramsSpec->specType) {
692         case HCF_COMMON_PARAMS_SPEC:
693             ret = CreateDsaCommonSpecImpl((HcfDsaCommParamsSpec *)paramsSpec, &spec);
694             break;
695         case HCF_PUBLIC_KEY_SPEC:
696             ret = CreateDsaPubKeySpecImpl((HcfDsaPubKeyParamsSpec *)paramsSpec, (HcfDsaPubKeyParamsSpec **)&spec);
697             break;
698         case HCF_KEY_PAIR_SPEC:
699             ret = CreateDsaKeyPairSpecImpl((HcfDsaKeyPairParamsSpec *)paramsSpec, (HcfDsaKeyPairParamsSpec **)&spec);
700             break;
701         default:
702             ret = HCF_INVALID_PARAMS;
703             break;
704     }
705     if (ret == HCF_SUCCESS) {
706         *impl = (HcfAsyKeyParamsSpec *)spec;
707     }
708     return ret;
709 }
710 
CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec * srcSpec,HcfDhPubKeyParamsSpec ** destSpec)711 static HcfResult CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec *srcSpec, HcfDhPubKeyParamsSpec **destSpec)
712 {
713     HcfDhPubKeyParamsSpec *spec = (HcfDhPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDhPubKeyParamsSpec), 0);
714     if (spec == NULL) {
715         LOGE("Failed to allocate dest spec memory");
716         return HCF_ERR_MALLOC;
717     }
718     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
719         LOGE("Failed to copy src spec");
720         HcfFree(spec);
721         return HCF_INVALID_PARAMS;
722     }
723     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
724     if (spec->pk.data == NULL) {
725         LOGE("Failed to allocate public key memory");
726         FreeDhCommParamsSpec(&(spec->base));
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 (!IsClassMatch((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 (!IsClassMatch((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 (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1234         return HCF_INVALID_PARAMS;
1235     }
1236     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1237     return impl->spiObj->engineConvertKey(impl->spiObj, params, pubKeyBlob, priKeyBlob, returnKeyPair);
1238 }
1239 
GenerateKeyPair(HcfAsyKeyGenerator * self,HcfParamsSpec * params,HcfKeyPair ** returnKeyPair)1240 static HcfResult GenerateKeyPair(HcfAsyKeyGenerator *self, HcfParamsSpec *params,
1241     HcfKeyPair **returnKeyPair)
1242 {
1243     (void)params;
1244     if (self == NULL) {
1245         LOGE("Invalid input parameter.");
1246         return HCF_INVALID_PARAMS;
1247     }
1248     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1249         return HCF_INVALID_PARAMS;
1250     }
1251     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1252     return impl->spiObj->engineGenerateKeyPair(impl->spiObj, returnKeyPair);
1253 }
1254 
GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfKeyPair ** returnKeyPair)1255 static HcfResult GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfKeyPair **returnKeyPair)
1256 {
1257     if (self == NULL) {
1258         LOGE("Invalid input parameter.");
1259         return HCF_INVALID_PARAMS;
1260     }
1261     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1262         return HCF_INVALID_PARAMS;
1263     }
1264     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1265     return impl->spiObj->engineGenerateKeyPairBySpec(impl->spiObj, impl->paramsSpec, returnKeyPair);
1266 }
1267 
GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPubKey ** returnPubKey)1268 static HcfResult GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPubKey **returnPubKey)
1269 {
1270     if (self == NULL) {
1271         LOGE("Invalid input parameter.");
1272         return HCF_INVALID_PARAMS;
1273     }
1274     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1275         return HCF_INVALID_PARAMS;
1276     }
1277     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1278     return impl->spiObj->engineGeneratePubKeyBySpec(impl->spiObj, impl->paramsSpec, returnPubKey);
1279 }
1280 
GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPriKey ** returnPriKey)1281 static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPriKey **returnPriKey)
1282 {
1283     if (self == NULL) {
1284         LOGE("Invalid input parameter.");
1285         return HCF_INVALID_PARAMS;
1286     }
1287     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1288         return HCF_INVALID_PARAMS;
1289     }
1290     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1291     return impl->spiObj->engineGeneratePriKeyBySpec(impl->spiObj, impl->paramsSpec, returnPriKey);
1292 }
1293 
DestroyAsyKeyGenerator(HcfObjectBase * self)1294 static void DestroyAsyKeyGenerator(HcfObjectBase *self)
1295 {
1296     if (self == NULL) {
1297         return;
1298     }
1299     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1300         return;
1301     }
1302     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1303     HcfObjDestroy(impl->spiObj);
1304     impl->spiObj = NULL;
1305     HcfFree(impl);
1306 }
1307 
DestroyAsyKeyGeneratorBySpec(HcfObjectBase * self)1308 static void DestroyAsyKeyGeneratorBySpec(HcfObjectBase *self)
1309 {
1310     if (self == NULL) {
1311         return;
1312     }
1313     if (!IsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1314         return;
1315     }
1316     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1317     HcfObjDestroy(impl->spiObj);
1318     impl->spiObj = NULL;
1319     FreeAsyKeySpec(impl->paramsSpec);
1320     impl->paramsSpec = NULL;
1321     HcfFree(impl);
1322 }
1323 
HcfAsyKeyGeneratorCreate(const char * algoName,HcfAsyKeyGenerator ** returnObj)1324 HcfResult HcfAsyKeyGeneratorCreate(const char *algoName, HcfAsyKeyGenerator **returnObj)
1325 {
1326     if ((!IsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) {
1327         return HCF_INVALID_PARAMS;
1328     }
1329 
1330     HcfAsyKeyGenParams params = { 0 };
1331     if (ParseAndSetParameter(algoName, &params, ParseAsyKeyGenParams) != HCF_SUCCESS) {
1332         LOGE("Failed to parse params!");
1333         return HCF_INVALID_PARAMS;
1334     }
1335 
1336     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1337     if (createSpiFunc == NULL) {
1338         return HCF_NOT_SUPPORT;
1339     }
1340 
1341     HcfAsyKeyGeneratorImpl *returnGenerator = (HcfAsyKeyGeneratorImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorImpl), 0);
1342     if (returnGenerator == NULL) {
1343         LOGE("Failed to allocate returnGenerator memory!");
1344         return HCF_ERR_MALLOC;
1345     }
1346     if (strcpy_s(returnGenerator->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) {
1347         LOGE("Failed to copy algoName!");
1348         HcfFree(returnGenerator);
1349         return HCF_INVALID_PARAMS;
1350     }
1351     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1352     HcfResult res = HCF_SUCCESS;
1353     res = createSpiFunc(&params, &spiObj);
1354     if (res != HCF_SUCCESS) {
1355         LOGE("Failed to create spi object!");
1356         HcfFree(returnGenerator);
1357         return res;
1358     }
1359     returnGenerator->base.base.destroy = DestroyAsyKeyGenerator;
1360     returnGenerator->base.base.getClass = GetAsyKeyGeneratorClass;
1361     returnGenerator->base.convertKey = ConvertKey;
1362     returnGenerator->base.generateKeyPair = GenerateKeyPair;
1363     returnGenerator->base.getAlgoName = GetAlgoName;
1364     returnGenerator->spiObj = spiObj;
1365     *returnObj = (HcfAsyKeyGenerator *)returnGenerator;
1366     return HCF_SUCCESS;
1367 }
1368 
HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyGeneratorBySpec ** returnObj)1369 HcfResult HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyGeneratorBySpec **returnObj)
1370 {
1371     if ((!IsParamsSpecValid(paramsSpec)) || (returnObj == NULL)) {
1372         return HCF_INVALID_PARAMS;
1373     }
1374     HcfAsyKeyGenParams params = { 0 };
1375     if (ParseAlgNameToParams(paramsSpec->algName, &params) != HCF_SUCCESS) {
1376         LOGE("Failed to parse params!");
1377         return HCF_INVALID_PARAMS;
1378     }
1379     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1380     if (createSpiFunc == NULL) {
1381         return HCF_NOT_SUPPORT;
1382     }
1383     HcfAsyKeyGeneratorBySpecImpl *returnGenerator =
1384         (HcfAsyKeyGeneratorBySpecImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorBySpecImpl), 0);
1385     if (returnGenerator == NULL) {
1386         LOGE("Failed to allocate returnGenerator memory!");
1387         return HCF_ERR_MALLOC;
1388     }
1389     HcfAsyKeyParamsSpec *paramsSpecImpl = NULL;
1390     HcfResult ret = CreateAsyKeyParamsSpecImpl(paramsSpec, params.algo, &paramsSpecImpl);
1391     if (ret != HCF_SUCCESS) {
1392         LOGE("Failed to create asy key params spec impl!");
1393         HcfFree(returnGenerator);
1394         return ret;
1395     }
1396     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1397     ret = createSpiFunc(&params, &spiObj);
1398     if (ret != HCF_SUCCESS) {
1399         LOGE("Failed to create spi object!");
1400         HcfFree(returnGenerator);
1401         FreeAsyKeySpec(paramsSpecImpl);
1402         return ret;
1403     }
1404     returnGenerator->base.base.destroy = DestroyAsyKeyGeneratorBySpec;
1405     returnGenerator->base.base.getClass = GetAsyKeyGeneratorBySpecClass;
1406     returnGenerator->base.generateKeyPair = GenerateKeyPairBySpec;
1407     returnGenerator->base.generatePubKey = GeneratePubKeyBySpec;
1408     returnGenerator->base.generatePriKey = GeneratePriKeyBySpec;
1409     returnGenerator->base.getAlgName = GetAlgNameBySpec;
1410     returnGenerator->paramsSpec = paramsSpecImpl;
1411     returnGenerator->spiObj = spiObj;
1412     *returnObj = (HcfAsyKeyGeneratorBySpec *)returnGenerator;
1413     return HCF_SUCCESS;
1414 }