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