• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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]: %{public}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]: %{public}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]: %{public}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]: %{public}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]: %{public}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]: %{public}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]: %{public}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         spec = NULL;
622         return HCF_INVALID_PARAMS;
623     }
624 
625     *destSpec = spec;
626     return HCF_SUCCESS;
627 }
628 
CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec * srcSpec,HcfDsaPubKeyParamsSpec ** destSpec)629 static HcfResult CreateDsaPubKeySpecImpl(const HcfDsaPubKeyParamsSpec *srcSpec, HcfDsaPubKeyParamsSpec **destSpec)
630 {
631     HcfDsaPubKeyParamsSpec *spec = (HcfDsaPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDsaPubKeyParamsSpec), 0);
632     if (spec == NULL) {
633         LOGE("Failed to allocate dest spec memory");
634         return HCF_ERR_MALLOC;
635     }
636     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
637         HcfFree(spec);
638         spec = NULL;
639         return HCF_INVALID_PARAMS;
640     }
641     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
642     if (spec->pk.data == NULL) {
643         LOGE("Failed to allocate public key memory");
644         FreeDsaCommParamsSpec(&(spec->base));
645         HcfFree(spec);
646         spec = NULL;
647         return HCF_ERR_MALLOC;
648     }
649     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
650     spec->pk.len = srcSpec->pk.len;
651 
652     *destSpec = spec;
653     return HCF_SUCCESS;
654 }
655 
CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec * srcSpec,HcfDsaKeyPairParamsSpec ** destSpec)656 static HcfResult CreateDsaKeyPairSpecImpl(const HcfDsaKeyPairParamsSpec *srcSpec, HcfDsaKeyPairParamsSpec **destSpec)
657 {
658     HcfDsaKeyPairParamsSpec *spec = (HcfDsaKeyPairParamsSpec *)HcfMalloc(sizeof(HcfDsaKeyPairParamsSpec), 0);
659     if (spec == NULL) {
660         LOGE("Failed to allocate dest spec memory");
661         return HCF_ERR_MALLOC;
662     }
663     if (CopyDsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
664         HcfFree(spec);
665         spec = NULL;
666         return HCF_INVALID_PARAMS;
667     }
668     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
669     if (spec->pk.data == NULL) {
670         LOGE("Failed to allocate public key memory");
671         FreeDsaCommParamsSpec(&(spec->base));
672         HcfFree(spec);
673         spec = NULL;
674         return HCF_ERR_MALLOC;
675     }
676     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
677     if (spec->sk.data == NULL) {
678         LOGE("Failed to allocate private key memory");
679         FreeDsaCommParamsSpec(&(spec->base));
680         HcfFree(spec->pk.data);
681         spec->pk.data = NULL;
682         HcfFree(spec);
683         spec = NULL;
684         return HCF_ERR_MALLOC;
685     }
686     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
687     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
688     spec->pk.len = srcSpec->pk.len;
689     spec->sk.len = srcSpec->sk.len;
690 
691     *destSpec = spec;
692     return HCF_SUCCESS;
693 }
694 
CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)695 static HcfResult CreateDsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
696 {
697     HcfResult ret = HCF_SUCCESS;
698     HcfDsaCommParamsSpec *spec = NULL;
699     switch (paramsSpec->specType) {
700         case HCF_COMMON_PARAMS_SPEC:
701             ret = CreateDsaCommonSpecImpl((HcfDsaCommParamsSpec *)paramsSpec, &spec);
702             break;
703         case HCF_PUBLIC_KEY_SPEC:
704             ret = CreateDsaPubKeySpecImpl((HcfDsaPubKeyParamsSpec *)paramsSpec, (HcfDsaPubKeyParamsSpec **)&spec);
705             break;
706         case HCF_KEY_PAIR_SPEC:
707             ret = CreateDsaKeyPairSpecImpl((HcfDsaKeyPairParamsSpec *)paramsSpec, (HcfDsaKeyPairParamsSpec **)&spec);
708             break;
709         default:
710             ret = HCF_INVALID_PARAMS;
711             break;
712     }
713     if (ret == HCF_SUCCESS) {
714         *impl = (HcfAsyKeyParamsSpec *)spec;
715     }
716     return ret;
717 }
718 
CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec * srcSpec,HcfDhPubKeyParamsSpec ** destSpec)719 static HcfResult CreateDhPubKeySpecImpl(const HcfDhPubKeyParamsSpec *srcSpec, HcfDhPubKeyParamsSpec **destSpec)
720 {
721     HcfDhPubKeyParamsSpec *spec = (HcfDhPubKeyParamsSpec *)HcfMalloc(sizeof(HcfDhPubKeyParamsSpec), 0);
722     if (spec == NULL) {
723         LOGE("Failed to allocate dest spec memory");
724         return HCF_ERR_MALLOC;
725     }
726     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
727         LOGE("Failed to copy src spec");
728         HcfFree(spec);
729         spec = NULL;
730         return HCF_INVALID_PARAMS;
731     }
732     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
733     if (spec->pk.data == NULL) {
734         LOGE("Failed to allocate public key memory");
735         DestroyDhPubKeySpec(spec);
736         return HCF_ERR_MALLOC;
737     }
738     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
739     spec->pk.len = srcSpec->pk.len;
740 
741     *destSpec = spec;
742     return HCF_SUCCESS;
743 }
744 
CreateDhPriKeySpecImpl(const HcfDhPriKeyParamsSpec * srcSpec,HcfDhPriKeyParamsSpec ** destSpec)745 static HcfResult CreateDhPriKeySpecImpl(const HcfDhPriKeyParamsSpec *srcSpec, HcfDhPriKeyParamsSpec **destSpec)
746 {
747     HcfDhPriKeyParamsSpec *spec = (HcfDhPriKeyParamsSpec *)HcfMalloc(sizeof(HcfDhPriKeyParamsSpec), 0);
748     if (spec == NULL) {
749         LOGE("Failed to allocate dest spec memory");
750         return HCF_ERR_MALLOC;
751     }
752     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
753         LOGE("Failed to copy src spec");
754         HcfFree(spec);
755         spec = NULL;
756         return HCF_INVALID_PARAMS;
757     }
758     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
759     if (spec->sk.data == NULL) {
760         LOGE("Failed to allocate private key memory");
761         FreeDhCommParamsSpec(&(spec->base));
762         HcfFree(spec);
763         spec = NULL;
764         return HCF_ERR_MALLOC;
765     }
766     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
767     spec->sk.len = srcSpec->sk.len;
768 
769     *destSpec = spec;
770     return HCF_SUCCESS;
771 }
772 
CreateDhKeyPairSpecImpl(const HcfDhKeyPairParamsSpec * srcSpec,HcfDhKeyPairParamsSpec ** destSpec)773 static HcfResult CreateDhKeyPairSpecImpl(const HcfDhKeyPairParamsSpec *srcSpec, HcfDhKeyPairParamsSpec **destSpec)
774 {
775     HcfDhKeyPairParamsSpec *spec = (HcfDhKeyPairParamsSpec *)HcfMalloc(sizeof(HcfDhKeyPairParamsSpec), 0);
776     if (spec == NULL) {
777         LOGE("Failed to allocate dest spec memory");
778         return HCF_ERR_MALLOC;
779     }
780     if (CopyDhCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
781         LOGE("Failed to copy src spec");
782         HcfFree(spec);
783         spec = NULL;
784         return HCF_INVALID_PARAMS;
785     }
786     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
787     if (spec->pk.data == NULL) {
788         LOGE("Failed to allocate public key memory");
789         FreeDhCommParamsSpec(&(spec->base));
790         HcfFree(spec);
791         spec = NULL;
792         return HCF_ERR_MALLOC;
793     }
794     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
795     if (spec->sk.data == NULL) {
796         LOGE("Failed to allocate private key memory");
797         FreeDhCommParamsSpec(&(spec->base));
798         HcfFree(spec->pk.data);
799         spec->pk.data = NULL;
800         HcfFree(spec);
801         spec = NULL;
802         return HCF_ERR_MALLOC;
803     }
804     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
805     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
806     spec->pk.len = srcSpec->pk.len;
807     spec->sk.len = srcSpec->sk.len;
808 
809     *destSpec = spec;
810     return HCF_SUCCESS;
811 }
812 
CreateDhParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)813 static HcfResult CreateDhParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
814 {
815     HcfResult ret = HCF_SUCCESS;
816     HcfDhCommParamsSpec *spec = NULL;
817     switch (paramsSpec->specType) {
818         case HCF_COMMON_PARAMS_SPEC:
819             ret = CreateDhCommonSpecImpl((HcfDhCommParamsSpec *)paramsSpec, &spec);
820             break;
821         case HCF_PUBLIC_KEY_SPEC:
822             ret = CreateDhPubKeySpecImpl((HcfDhPubKeyParamsSpec *)paramsSpec, (HcfDhPubKeyParamsSpec **)&spec);
823             break;
824         case HCF_PRIVATE_KEY_SPEC:
825             ret = CreateDhPriKeySpecImpl((HcfDhPriKeyParamsSpec *)paramsSpec, (HcfDhPriKeyParamsSpec **)&spec);
826             break;
827         case HCF_KEY_PAIR_SPEC:
828             ret = CreateDhKeyPairSpecImpl((HcfDhKeyPairParamsSpec *)paramsSpec, (HcfDhKeyPairParamsSpec **)&spec);
829             break;
830         default:
831             LOGE("Invalid spec type [%{public}d]", paramsSpec->specType);
832             ret = HCF_INVALID_PARAMS;
833             break;
834     }
835     if (ret == HCF_SUCCESS) {
836         *impl = (HcfAsyKeyParamsSpec *)spec;
837     }
838     return ret;
839 }
840 
CreateEccPubKeySpecImpl(const HcfEccPubKeyParamsSpec * srcSpec,HcfEccPubKeyParamsSpec ** destSpec)841 static HcfResult CreateEccPubKeySpecImpl(const HcfEccPubKeyParamsSpec *srcSpec, HcfEccPubKeyParamsSpec **destSpec)
842 {
843     HcfEccPubKeyParamsSpec *tmpSpec = (HcfEccPubKeyParamsSpec *)HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0);
844     if (tmpSpec == NULL) {
845         LOGE("Failed to allocate dest spec memory");
846         return HCF_ERR_MALLOC;
847     }
848     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
849         HcfFree(tmpSpec);
850         tmpSpec = NULL;
851         return HCF_INVALID_PARAMS;
852     }
853     HcfResult res = CopyPoint(&(srcSpec->pk), &(tmpSpec->pk));
854     if (res != HCF_SUCCESS) {
855         LOGE("Failed to allocate public key memory");
856         FreeEccCommParamsSpec(&(tmpSpec->base));
857         HcfFree(tmpSpec);
858         tmpSpec = NULL;
859         return res;
860     }
861 
862     *destSpec = tmpSpec;
863     return HCF_SUCCESS;
864 }
865 
CreateEccPriKeySpecImpl(const HcfEccPriKeyParamsSpec * srcSpec,HcfEccPriKeyParamsSpec ** destSpec)866 static HcfResult CreateEccPriKeySpecImpl(const HcfEccPriKeyParamsSpec *srcSpec, HcfEccPriKeyParamsSpec **destSpec)
867 {
868     HcfEccPriKeyParamsSpec *tmpSpec = (HcfEccPriKeyParamsSpec *)HcfMalloc(sizeof(HcfEccPriKeyParamsSpec), 0);
869     if (tmpSpec == NULL) {
870         LOGE("Failed to allocate dest spec memory");
871         return HCF_ERR_MALLOC;
872     }
873     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
874         HcfFree(tmpSpec);
875         tmpSpec = NULL;
876         return HCF_INVALID_PARAMS;
877     }
878     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
879     if (tmpSpec->sk.data == NULL) {
880         LOGE("Failed to allocate private key memory");
881         FreeEccCommParamsSpec(&(tmpSpec->base));
882         HcfFree(tmpSpec);
883         tmpSpec = NULL;
884         return HCF_ERR_MALLOC;
885     }
886     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
887     tmpSpec->sk.len = srcSpec->sk.len;
888 
889     *destSpec = tmpSpec;
890     return HCF_SUCCESS;
891 }
892 
CreateEccKeyPairSpecImpl(const HcfEccKeyPairParamsSpec * srcSpec,HcfEccKeyPairParamsSpec ** destSpec)893 static HcfResult CreateEccKeyPairSpecImpl(const HcfEccKeyPairParamsSpec *srcSpec, HcfEccKeyPairParamsSpec **destSpec)
894 {
895     HcfEccKeyPairParamsSpec *tmpSpec = (HcfEccKeyPairParamsSpec *)HcfMalloc(sizeof(HcfEccKeyPairParamsSpec), 0);
896     if (tmpSpec == NULL) {
897         LOGE("Failed to allocate dest spec memory");
898         return HCF_ERR_MALLOC;
899     }
900     if (CopyEccCommonSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
901         HcfFree(tmpSpec);
902         tmpSpec = NULL;
903         return HCF_INVALID_PARAMS;
904     }
905     HcfResult res = CopyPoint(&(srcSpec->pk), &(tmpSpec->pk));
906     if (res != HCF_SUCCESS) {
907         LOGE("Failed to allocate public key memory");
908         FreeEccCommParamsSpec(&(tmpSpec->base));
909         HcfFree(tmpSpec);
910         tmpSpec = NULL;
911         return res;
912     }
913     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
914     if (tmpSpec->sk.data == NULL) {
915         LOGE("Failed to allocate private key memory");
916         FreeEccCommParamsSpec(&(tmpSpec->base));
917         HcfFree(tmpSpec->pk.x.data);
918         tmpSpec->pk.x.data = NULL;
919         HcfFree(tmpSpec->pk.y.data);
920         tmpSpec->pk.y.data = NULL;
921         HcfFree(tmpSpec);
922         tmpSpec = NULL;
923         return HCF_ERR_MALLOC;
924     }
925     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
926     tmpSpec->sk.len = srcSpec->sk.len;
927 
928     *destSpec = tmpSpec;
929     return HCF_SUCCESS;
930 }
931 
CreateEccParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)932 static HcfResult CreateEccParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
933 {
934     HcfResult ret = HCF_SUCCESS;
935     HcfEccCommParamsSpec *spec = NULL;
936     switch (paramsSpec->specType) {
937         case HCF_COMMON_PARAMS_SPEC:
938             ret = CreateEccCommonSpecImpl((HcfEccCommParamsSpec *)paramsSpec, &spec);
939             break;
940         case HCF_PUBLIC_KEY_SPEC:
941             ret = CreateEccPubKeySpecImpl((HcfEccPubKeyParamsSpec *)paramsSpec, (HcfEccPubKeyParamsSpec **)(&spec));
942             break;
943         case HCF_PRIVATE_KEY_SPEC:
944             ret = CreateEccPriKeySpecImpl((HcfEccPriKeyParamsSpec *)paramsSpec, (HcfEccPriKeyParamsSpec **)(&spec));
945             break;
946         case HCF_KEY_PAIR_SPEC:
947             ret = CreateEccKeyPairSpecImpl((HcfEccKeyPairParamsSpec *)paramsSpec, (HcfEccKeyPairParamsSpec **)(&spec));
948             break;
949         default:
950             ret = HCF_INVALID_PARAMS;
951             break;
952     }
953     if (ret == HCF_SUCCESS) {
954         *impl = (HcfAsyKeyParamsSpec *)spec;
955     }
956     return ret;
957 }
958 
CopyRsaCommonSpec(const HcfRsaCommParamsSpec * srcSpec,HcfRsaCommParamsSpec * destSpec)959 static HcfResult CopyRsaCommonSpec(const HcfRsaCommParamsSpec *srcSpec, HcfRsaCommParamsSpec *destSpec)
960 {
961     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
962         return HCF_INVALID_PARAMS;
963     }
964     destSpec->n.data = (unsigned char *)HcfMalloc(srcSpec->n.len, 0);
965     if (destSpec->n.data == NULL) {
966         LOGE("Failed to allocate n data memory");
967         HcfFree(destSpec->base.algName);
968         destSpec->base.algName = NULL;
969         return HCF_ERR_MALLOC;
970     }
971     (void)memcpy_s(destSpec->n.data, srcSpec->n.len, srcSpec->n.data, srcSpec->n.len);
972     destSpec->n.len = srcSpec->n.len;
973     return HCF_SUCCESS;
974 }
975 
CreateRsaPubKeySpecImpl(const HcfRsaPubKeyParamsSpec * srcSpec,HcfRsaPubKeyParamsSpec ** destSpec)976 static HcfResult CreateRsaPubKeySpecImpl(const HcfRsaPubKeyParamsSpec *srcSpec, HcfRsaPubKeyParamsSpec **destSpec)
977 {
978     HcfRsaPubKeyParamsSpec *spec = (HcfRsaPubKeyParamsSpec *)HcfMalloc(sizeof(HcfRsaPubKeyParamsSpec), 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         spec = NULL;
986         return HCF_INVALID_PARAMS;
987     }
988     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
989     if (spec->pk.data == NULL) {
990         LOGE("Failed to allocate public key memory");
991         DestroyRsaPubKeySpec(spec);
992         return HCF_ERR_MALLOC;
993     }
994     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
995     spec->pk.len = srcSpec->pk.len;
996 
997     *destSpec = spec;
998     return HCF_SUCCESS;
999 }
1000 
CreateRsaKeyPairSpecImpl(const HcfRsaKeyPairParamsSpec * srcSpec,HcfRsaKeyPairParamsSpec ** destSpec)1001 static HcfResult CreateRsaKeyPairSpecImpl(const HcfRsaKeyPairParamsSpec *srcSpec, HcfRsaKeyPairParamsSpec **destSpec)
1002 {
1003     HcfRsaKeyPairParamsSpec *spec = (HcfRsaKeyPairParamsSpec *)HcfMalloc(sizeof(HcfRsaKeyPairParamsSpec), 0);
1004     if (spec == NULL) {
1005         LOGE("Failed to allocate dest spec memory");
1006         return HCF_ERR_MALLOC;
1007     }
1008     if (CopyRsaCommonSpec(&(srcSpec->base), &(spec->base)) != HCF_SUCCESS) {
1009         HcfFree(spec);
1010         spec = NULL;
1011         return HCF_INVALID_PARAMS;
1012     }
1013     spec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
1014     if (spec->pk.data == NULL) {
1015         LOGE("Failed to allocate public key memory");
1016         FreeRsaCommParamsSpec(&(spec->base));
1017         HcfFree(spec);
1018         spec = NULL;
1019         return HCF_ERR_MALLOC;
1020     }
1021     spec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
1022     if (spec->sk.data == NULL) {
1023         LOGE("Failed to allocate private key memory");
1024         FreeRsaCommParamsSpec(&(spec->base));
1025         HcfFree(spec->pk.data);
1026         spec->pk.data = NULL;
1027         HcfFree(spec);
1028         spec = NULL;
1029         return HCF_ERR_MALLOC;
1030     }
1031     (void)memcpy_s(spec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1032     (void)memcpy_s(spec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1033     spec->pk.len = srcSpec->pk.len;
1034     spec->sk.len = srcSpec->sk.len;
1035 
1036     *destSpec = spec;
1037     return HCF_SUCCESS;
1038 }
1039 
CreateRsaParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)1040 static HcfResult CreateRsaParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
1041 {
1042     HcfResult ret = HCF_SUCCESS;
1043     HcfRsaCommParamsSpec *spec = NULL;
1044     switch (paramsSpec->specType) {
1045         // commonspe should not be used in RSA
1046         case HCF_COMMON_PARAMS_SPEC:
1047             LOGE("RSA not support comm spec");
1048             ret = HCF_INVALID_PARAMS;
1049             break;
1050         case HCF_PUBLIC_KEY_SPEC:
1051             ret = CreateRsaPubKeySpecImpl((HcfRsaPubKeyParamsSpec *)paramsSpec, (HcfRsaPubKeyParamsSpec **)&spec);
1052             break;
1053         case HCF_KEY_PAIR_SPEC:
1054             ret = CreateRsaKeyPairSpecImpl((HcfRsaKeyPairParamsSpec *)paramsSpec, (HcfRsaKeyPairParamsSpec **)&spec);
1055             break;
1056         default:
1057             ret = HCF_INVALID_PARAMS;
1058             break;
1059     }
1060     if (ret == HCF_SUCCESS) {
1061         *impl = (HcfAsyKeyParamsSpec *)spec;
1062     }
1063     return ret;
1064 }
1065 
CreateAlg25519PubKeySpecImpl(const HcfAlg25519PubKeyParamsSpec * srcSpec,HcfAlg25519PubKeyParamsSpec ** destSpec)1066 static HcfResult CreateAlg25519PubKeySpecImpl(const HcfAlg25519PubKeyParamsSpec *srcSpec,
1067     HcfAlg25519PubKeyParamsSpec **destSpec)
1068 {
1069     HcfAlg25519PubKeyParamsSpec *tmpSpec =
1070         (HcfAlg25519PubKeyParamsSpec *)HcfMalloc(sizeof(HcfAlg25519PubKeyParamsSpec), 0);
1071     if (tmpSpec == NULL) {
1072         LOGE("Failed to allocate dest spec memory");
1073         return HCF_ERR_MALLOC;
1074     }
1075     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1076         DestroyAlg25519PubKeySpec(tmpSpec);
1077         LOGE("Copy alg25519 commonSpec memory");
1078         return HCF_INVALID_PARAMS;
1079     }
1080     tmpSpec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
1081     if (tmpSpec->pk.data == NULL) {
1082         LOGE("Failed to allocate private key memory");
1083         DestroyAlg25519PubKeySpec(tmpSpec);
1084         return HCF_ERR_MALLOC;
1085     }
1086     (void)memcpy_s(tmpSpec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1087     tmpSpec->pk.len = srcSpec->pk.len;
1088 
1089     *destSpec = tmpSpec;
1090     return HCF_SUCCESS;
1091 }
1092 
CreateAlg25519PriKeySpecImpl(const HcfAlg25519PriKeyParamsSpec * srcSpec,HcfAlg25519PriKeyParamsSpec ** destSpec)1093 static HcfResult CreateAlg25519PriKeySpecImpl(const HcfAlg25519PriKeyParamsSpec *srcSpec,
1094     HcfAlg25519PriKeyParamsSpec **destSpec)
1095 {
1096     HcfAlg25519PriKeyParamsSpec *tmpSpec =
1097         (HcfAlg25519PriKeyParamsSpec *)HcfMalloc(sizeof(HcfAlg25519PriKeyParamsSpec), 0);
1098     if (tmpSpec == NULL) {
1099         LOGE("Failed to allocate dest spec memory");
1100         return HCF_ERR_MALLOC;
1101     }
1102     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1103         DestroyAlg25519PriKeySpec(tmpSpec);
1104         LOGE("Copy alg25519 commonSpec memory");
1105         return HCF_INVALID_PARAMS;
1106     }
1107     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
1108     if (tmpSpec->sk.data == NULL) {
1109         LOGE("Failed to allocate private key memory");
1110         DestroyAlg25519PriKeySpec(tmpSpec);
1111         return HCF_ERR_MALLOC;
1112     }
1113     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1114     tmpSpec->sk.len = srcSpec->sk.len;
1115 
1116     *destSpec = tmpSpec;
1117     return HCF_SUCCESS;
1118 }
1119 
CreateAlg25519KeyPairSpecImpl(const HcfAlg25519KeyPairParamsSpec * srcSpec,HcfAlg25519KeyPairParamsSpec ** destSpec)1120 static HcfResult CreateAlg25519KeyPairSpecImpl(const HcfAlg25519KeyPairParamsSpec *srcSpec,
1121     HcfAlg25519KeyPairParamsSpec **destSpec)
1122 {
1123     HcfAlg25519KeyPairParamsSpec *tmpSpec =
1124         (HcfAlg25519KeyPairParamsSpec *)HcfMalloc(sizeof(HcfAlg25519KeyPairParamsSpec), 0);
1125     if (tmpSpec == NULL) {
1126         LOGE("Failed to allocate dest spec memory");
1127         return HCF_ERR_MALLOC;
1128     }
1129     if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(tmpSpec->base)) != HCF_SUCCESS) {
1130         DestroyAlg25519KeyPairSpec(tmpSpec);
1131         LOGE("Copy alg25519 commonSpec memory");
1132         return HCF_INVALID_PARAMS;
1133     }
1134     tmpSpec->pk.data = (unsigned char *)HcfMalloc(srcSpec->pk.len, 0);
1135     if (tmpSpec->pk.data == NULL) {
1136         LOGE("Failed to allocate private key memory");
1137         DestroyAlg25519KeyPairSpec(tmpSpec);
1138         return HCF_ERR_MALLOC;
1139     }
1140 
1141     tmpSpec->sk.data = (unsigned char *)HcfMalloc(srcSpec->sk.len, 0);
1142     if (tmpSpec->sk.data == NULL) {
1143         LOGE("Failed to allocate private key memory");
1144         DestroyAlg25519KeyPairSpec(tmpSpec);
1145         return HCF_ERR_MALLOC;
1146     }
1147     (void)memcpy_s(tmpSpec->pk.data, srcSpec->pk.len, srcSpec->pk.data, srcSpec->pk.len);
1148     tmpSpec->pk.len = srcSpec->pk.len;
1149     (void)memcpy_s(tmpSpec->sk.data, srcSpec->sk.len, srcSpec->sk.data, srcSpec->sk.len);
1150     tmpSpec->sk.len = srcSpec->sk.len;
1151 
1152     *destSpec = tmpSpec;
1153     return HCF_SUCCESS;
1154 }
1155 
CreateAlg25519ParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyParamsSpec ** impl)1156 static HcfResult CreateAlg25519ParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyParamsSpec **impl)
1157 {
1158     HcfResult ret = HCF_SUCCESS;
1159     HcfAlg25519PubKeyParamsSpec *pubKeySpec = NULL;
1160     HcfAlg25519PriKeyParamsSpec *priKeySpec = NULL;
1161     HcfAlg25519KeyPairParamsSpec *keyPairSpec = NULL;
1162     switch (paramsSpec->specType) {
1163         case HCF_PUBLIC_KEY_SPEC:
1164             ret = CreateAlg25519PubKeySpecImpl((HcfAlg25519PubKeyParamsSpec *)paramsSpec, &pubKeySpec);
1165             if (ret == HCF_SUCCESS) {
1166                 *impl = (HcfAsyKeyParamsSpec *)pubKeySpec;
1167             }
1168             break;
1169         case HCF_PRIVATE_KEY_SPEC:
1170             ret = CreateAlg25519PriKeySpecImpl((HcfAlg25519PriKeyParamsSpec *)paramsSpec, &priKeySpec);
1171             if (ret == HCF_SUCCESS) {
1172                 *impl = (HcfAsyKeyParamsSpec *)priKeySpec;
1173             }
1174             break;
1175         case HCF_KEY_PAIR_SPEC:
1176             ret = CreateAlg25519KeyPairSpecImpl((HcfAlg25519KeyPairParamsSpec *)paramsSpec, &keyPairSpec);
1177             if (ret == HCF_SUCCESS) {
1178                 *impl = (HcfAsyKeyParamsSpec *)keyPairSpec;
1179             }
1180             break;
1181         default:
1182             LOGE("SpecType not support! [SpecType]: %{public}d", paramsSpec->specType);
1183             ret = HCF_INVALID_PARAMS;
1184             break;
1185     }
1186     return ret;
1187 }
1188 
CreateAsyKeyParamsSpecImpl(const HcfAsyKeyParamsSpec * paramsSpec,HcfAlgValue alg,HcfAsyKeyParamsSpec ** impl)1189 static HcfResult CreateAsyKeyParamsSpecImpl(const HcfAsyKeyParamsSpec *paramsSpec, HcfAlgValue alg,
1190     HcfAsyKeyParamsSpec **impl)
1191 {
1192     HcfResult ret = HCF_SUCCESS;
1193     switch (alg) {
1194         case HCF_ALG_DSA:
1195             ret = CreateDsaParamsSpecImpl(paramsSpec, impl);
1196             break;
1197         case HCF_ALG_SM2:
1198         case HCF_ALG_ECC:
1199             ret = CreateEccParamsSpecImpl(paramsSpec, impl);
1200             break;
1201         case HCF_ALG_RSA:
1202             ret = CreateRsaParamsSpecImpl(paramsSpec, impl);
1203             break;
1204         case HCF_ALG_ED25519:
1205         case HCF_ALG_X25519:
1206             ret = CreateAlg25519ParamsSpecImpl(paramsSpec, impl);
1207             break;
1208         case HCF_ALG_DH:
1209             ret = CreateDhParamsSpecImpl(paramsSpec, impl);
1210             break;
1211         default:
1212             ret = HCF_INVALID_PARAMS;
1213             break;
1214     }
1215     return ret;
1216 }
1217 
1218 // export interfaces
GetAsyKeyGeneratorClass(void)1219 static const char *GetAsyKeyGeneratorClass(void)
1220 {
1221     return ASY_KEY_GENERATOR_CLASS;
1222 }
1223 
GetAsyKeyGeneratorBySpecClass(void)1224 static const char *GetAsyKeyGeneratorBySpecClass(void)
1225 {
1226     return ASY_KEY_GENERATOR_BY_SPEC_CLASS;
1227 }
1228 
GetAlgoName(HcfAsyKeyGenerator * self)1229 static const char *GetAlgoName(HcfAsyKeyGenerator *self)
1230 {
1231     if (self == NULL) {
1232         LOGE("The input self ptr is NULL!");
1233         return NULL;
1234     }
1235     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1236         return NULL;
1237     }
1238     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1239     return impl->algoName;
1240 }
1241 
GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec * self)1242 static const char *GetAlgNameBySpec(const HcfAsyKeyGeneratorBySpec *self)
1243 {
1244     if (self == NULL) {
1245         LOGE("The input self ptr is NULL!");
1246         return NULL;
1247     }
1248     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1249         return NULL;
1250     }
1251     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1252     return impl->paramsSpec->algName;
1253 }
1254 
ConvertKey(HcfAsyKeyGenerator * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)1255 static HcfResult ConvertKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
1256     HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
1257 {
1258     if (self == NULL) {
1259         LOGE("Invalid input parameter.");
1260         return HCF_INVALID_PARAMS;
1261     }
1262     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1263         return HCF_INVALID_PARAMS;
1264     }
1265     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1266     if (impl->spiObj == NULL || impl->spiObj->engineConvertKey == NULL) {
1267         LOGE("Invalid input parameter.");
1268         return HCF_INVALID_PARAMS;
1269     }
1270     return impl->spiObj->engineConvertKey(impl->spiObj, params, pubKeyBlob, priKeyBlob, returnKeyPair);
1271 }
1272 
ConvertPemKey(HcfAsyKeyGenerator * self,HcfParamsSpec * params,const char * pubKeyStr,const char * priKeyStr,HcfKeyPair ** returnKeyPair)1273 static HcfResult ConvertPemKey(HcfAsyKeyGenerator *self, HcfParamsSpec *params, const char *pubKeyStr,
1274     const char *priKeyStr, HcfKeyPair **returnKeyPair)
1275 {
1276     if (self == NULL) {
1277         LOGE("Invalid input parameter.");
1278         return HCF_INVALID_PARAMS;
1279     }
1280     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1281         return HCF_INVALID_PARAMS;
1282     }
1283     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1284     if (impl->spiObj == NULL || impl->spiObj->engineConvertPemKey == NULL) {
1285         LOGE("Invalid input parameter.");
1286         return HCF_INVALID_PARAMS;
1287     }
1288     return impl->spiObj->engineConvertPemKey(impl->spiObj, params, pubKeyStr, priKeyStr, returnKeyPair);
1289 }
1290 
GenerateKeyPair(HcfAsyKeyGenerator * self,HcfParamsSpec * params,HcfKeyPair ** returnKeyPair)1291 static HcfResult GenerateKeyPair(HcfAsyKeyGenerator *self, HcfParamsSpec *params,
1292     HcfKeyPair **returnKeyPair)
1293 {
1294     (void)params;
1295     if (self == NULL) {
1296         LOGE("Invalid input parameter.");
1297         return HCF_INVALID_PARAMS;
1298     }
1299     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1300         return HCF_INVALID_PARAMS;
1301     }
1302     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1303     if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPair == NULL) {
1304         LOGE("Invalid input parameter.");
1305         return HCF_INVALID_PARAMS;
1306     }
1307     return impl->spiObj->engineGenerateKeyPair(impl->spiObj, returnKeyPair);
1308 }
1309 
GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfKeyPair ** returnKeyPair)1310 static HcfResult GenerateKeyPairBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfKeyPair **returnKeyPair)
1311 {
1312     if (self == NULL) {
1313         LOGE("Invalid input parameter.");
1314         return HCF_INVALID_PARAMS;
1315     }
1316     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1317         return HCF_INVALID_PARAMS;
1318     }
1319     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1320     if (impl->spiObj == NULL || impl->spiObj->engineGenerateKeyPairBySpec == NULL) {
1321         LOGE("Invalid input parameter.");
1322         return HCF_INVALID_PARAMS;
1323     }
1324     return impl->spiObj->engineGenerateKeyPairBySpec(impl->spiObj, impl->paramsSpec, returnKeyPair);
1325 }
1326 
GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPubKey ** returnPubKey)1327 static HcfResult GeneratePubKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPubKey **returnPubKey)
1328 {
1329     if (self == NULL) {
1330         LOGE("Invalid input parameter.");
1331         return HCF_INVALID_PARAMS;
1332     }
1333     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1334         return HCF_INVALID_PARAMS;
1335     }
1336     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1337     if (impl->spiObj == NULL || impl->spiObj->engineGeneratePubKeyBySpec == NULL) {
1338         LOGE("Invalid input parameter.");
1339         return HCF_INVALID_PARAMS;
1340     }
1341     return impl->spiObj->engineGeneratePubKeyBySpec(impl->spiObj, impl->paramsSpec, returnPubKey);
1342 }
1343 
GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec * self,HcfPriKey ** returnPriKey)1344 static HcfResult GeneratePriKeyBySpec(const HcfAsyKeyGeneratorBySpec *self, HcfPriKey **returnPriKey)
1345 {
1346     if (self == NULL) {
1347         LOGE("Invalid input parameter.");
1348         return HCF_INVALID_PARAMS;
1349     }
1350     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1351         return HCF_INVALID_PARAMS;
1352     }
1353     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1354     if (impl->spiObj == NULL || impl->spiObj->engineGeneratePriKeyBySpec == NULL) {
1355         LOGE("Invalid input parameter.");
1356         return HCF_INVALID_PARAMS;
1357     }
1358     return impl->spiObj->engineGeneratePriKeyBySpec(impl->spiObj, impl->paramsSpec, returnPriKey);
1359 }
1360 
DestroyAsyKeyGenerator(HcfObjectBase * self)1361 static void DestroyAsyKeyGenerator(HcfObjectBase *self)
1362 {
1363     if (self == NULL) {
1364         return;
1365     }
1366     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorClass())) {
1367         return;
1368     }
1369     HcfAsyKeyGeneratorImpl *impl = (HcfAsyKeyGeneratorImpl *)self;
1370     HcfObjDestroy(impl->spiObj);
1371     impl->spiObj = NULL;
1372     HcfFree(impl);
1373 }
1374 
DestroyAsyKeyGeneratorBySpec(HcfObjectBase * self)1375 static void DestroyAsyKeyGeneratorBySpec(HcfObjectBase *self)
1376 {
1377     if (self == NULL) {
1378         return;
1379     }
1380     if (!HcfIsClassMatch((HcfObjectBase *)self, GetAsyKeyGeneratorBySpecClass())) {
1381         return;
1382     }
1383     HcfAsyKeyGeneratorBySpecImpl *impl = (HcfAsyKeyGeneratorBySpecImpl *)self;
1384     HcfObjDestroy(impl->spiObj);
1385     impl->spiObj = NULL;
1386     FreeAsyKeySpec(impl->paramsSpec);
1387     impl->paramsSpec = NULL;
1388     HcfFree(impl);
1389 }
1390 
HcfAsyKeyGeneratorCreate(const char * algoName,HcfAsyKeyGenerator ** returnObj)1391 HcfResult HcfAsyKeyGeneratorCreate(const char *algoName, HcfAsyKeyGenerator **returnObj)
1392 {
1393     if ((!HcfIsStrValid(algoName, HCF_MAX_ALGO_NAME_LEN)) || (returnObj == NULL)) {
1394         return HCF_INVALID_PARAMS;
1395     }
1396 
1397     HcfAsyKeyGenParams params = { 0 };
1398     if (ParseAndSetParameter(algoName, &params, ParseAsyKeyGenParams) != HCF_SUCCESS) {
1399         LOGE("Failed to parse params!");
1400         return HCF_INVALID_PARAMS;
1401     }
1402 
1403     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1404     if (createSpiFunc == NULL) {
1405         return HCF_NOT_SUPPORT;
1406     }
1407 
1408     HcfAsyKeyGeneratorImpl *returnGenerator = (HcfAsyKeyGeneratorImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorImpl), 0);
1409     if (returnGenerator == NULL) {
1410         LOGE("Failed to allocate returnGenerator memory!");
1411         return HCF_ERR_MALLOC;
1412     }
1413     if (strcpy_s(returnGenerator->algoName, HCF_MAX_ALGO_NAME_LEN, algoName) != EOK) {
1414         LOGE("Failed to copy algoName!");
1415         HcfFree(returnGenerator);
1416         returnGenerator = NULL;
1417         return HCF_INVALID_PARAMS;
1418     }
1419     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1420     HcfResult res = HCF_SUCCESS;
1421     res = createSpiFunc(&params, &spiObj);
1422     if (res != HCF_SUCCESS) {
1423         LOGE("Failed to create spi object!");
1424         HcfFree(returnGenerator);
1425         returnGenerator = NULL;
1426         return res;
1427     }
1428     returnGenerator->base.base.destroy = DestroyAsyKeyGenerator;
1429     returnGenerator->base.base.getClass = GetAsyKeyGeneratorClass;
1430     returnGenerator->base.convertKey = ConvertKey;
1431     returnGenerator->base.convertPemKey = ConvertPemKey;
1432     returnGenerator->base.generateKeyPair = GenerateKeyPair;
1433     returnGenerator->base.getAlgoName = GetAlgoName;
1434     returnGenerator->spiObj = spiObj;
1435     *returnObj = (HcfAsyKeyGenerator *)returnGenerator;
1436     return HCF_SUCCESS;
1437 }
1438 
HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec * paramsSpec,HcfAsyKeyGeneratorBySpec ** returnObj)1439 HcfResult HcfAsyKeyGeneratorBySpecCreate(const HcfAsyKeyParamsSpec *paramsSpec, HcfAsyKeyGeneratorBySpec **returnObj)
1440 {
1441     if ((!IsParamsSpecValid(paramsSpec)) || (returnObj == NULL)) {
1442         return HCF_INVALID_PARAMS;
1443     }
1444     HcfAsyKeyGenParams params = { 0 };
1445     if (ParseAlgNameToParams(paramsSpec->algName, &params) != HCF_SUCCESS) {
1446         LOGE("Failed to parse params!");
1447         return HCF_INVALID_PARAMS;
1448     }
1449     HcfAsyKeyGeneratorSpiCreateFunc createSpiFunc = FindAbility(&params);
1450     if (createSpiFunc == NULL) {
1451         return HCF_NOT_SUPPORT;
1452     }
1453     HcfAsyKeyGeneratorBySpecImpl *returnGenerator =
1454         (HcfAsyKeyGeneratorBySpecImpl *)HcfMalloc(sizeof(HcfAsyKeyGeneratorBySpecImpl), 0);
1455     if (returnGenerator == NULL) {
1456         LOGE("Failed to allocate returnGenerator memory!");
1457         return HCF_ERR_MALLOC;
1458     }
1459     HcfAsyKeyParamsSpec *paramsSpecImpl = NULL;
1460     HcfResult ret = CreateAsyKeyParamsSpecImpl(paramsSpec, params.algo, &paramsSpecImpl);
1461     if (ret != HCF_SUCCESS) {
1462         LOGE("Failed to create asy key params spec impl!");
1463         HcfFree(returnGenerator);
1464         returnGenerator = NULL;
1465         return ret;
1466     }
1467     HcfAsyKeyGeneratorSpi *spiObj = NULL;
1468     ret = createSpiFunc(&params, &spiObj);
1469     if (ret != HCF_SUCCESS) {
1470         LOGE("Failed to create spi object!");
1471         HcfFree(returnGenerator);
1472         returnGenerator = NULL;
1473         FreeAsyKeySpec(paramsSpecImpl);
1474         paramsSpecImpl = NULL;
1475         return ret;
1476     }
1477     returnGenerator->base.base.destroy = DestroyAsyKeyGeneratorBySpec;
1478     returnGenerator->base.base.getClass = GetAsyKeyGeneratorBySpecClass;
1479     returnGenerator->base.generateKeyPair = GenerateKeyPairBySpec;
1480     returnGenerator->base.generatePubKey = GeneratePubKeyBySpec;
1481     returnGenerator->base.generatePriKey = GeneratePriKeyBySpec;
1482     returnGenerator->base.getAlgName = GetAlgNameBySpec;
1483     returnGenerator->paramsSpec = paramsSpecImpl;
1484     returnGenerator->spiObj = spiObj;
1485     *returnObj = (HcfAsyKeyGeneratorBySpec *)returnGenerator;
1486     return HCF_SUCCESS;
1487 }