1 /*
2 * Copyright (C) 2022 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 "ecc_asy_key_generator_openssl.h"
17
18 #include "securec.h"
19 #include "openssl/pem.h"
20 #include "openssl/x509.h"
21
22 #include "algorithm_parameter.h"
23 #include "log.h"
24 #include "memory.h"
25 #include "openssl_class.h"
26 #include "openssl_common.h"
27 #include "utils.h"
28
29 #define OPENSSL_ECC_KEY_GENERATOR_CLASS "OPENSSL.ECC.KEY_GENERATOR_CLASS"
30 #define OPENSSL_ECC_ALGORITHM "EC"
31 #define OPENSSL_ECC_PUB_KEY_FORMAT "X.509"
32 #define OPENSSL_ECC_PRI_KEY_FORMAT "PKCS#8"
33
34 typedef struct {
35 HcfAsyKeyGeneratorSpi base;
36
37 int32_t curveId;
38 } HcfAsyKeyGeneratorSpiOpensslEccImpl;
39
NewEcKeyPairByOpenssl(int32_t curveId,EC_POINT ** returnPubKey,BIGNUM ** returnPriKey)40 static HcfResult NewEcKeyPairByOpenssl(int32_t curveId, EC_POINT **returnPubKey, BIGNUM **returnPriKey)
41 {
42 EC_KEY *ecKey = EC_KEY_new_by_curve_name(curveId);
43 if (ecKey == NULL) {
44 LOGE("new ec key failed.");
45 return HCF_ERR_CRYPTO_OPERATION;
46 }
47 if (EC_KEY_generate_key(ecKey) <= 0) {
48 LOGE("generate ec key failed.");
49 EC_KEY_free(ecKey);
50 return HCF_ERR_CRYPTO_OPERATION;
51 }
52 if (EC_KEY_check_key(ecKey) <= 0) {
53 LOGE("check key fail.");
54 EC_KEY_free(ecKey);
55 return HCF_ERR_CRYPTO_OPERATION;
56 }
57 const EC_POINT *pubKey = EC_KEY_get0_public_key(ecKey);
58 const BIGNUM *priKey = EC_KEY_get0_private_key(ecKey);
59 const EC_GROUP *group = EC_KEY_get0_group(ecKey);
60 if ((pubKey == NULL) || (priKey == NULL) || (group == NULL)) {
61 LOGE("ec key is invalid.");
62 EC_KEY_free(ecKey);
63 return HCF_ERR_CRYPTO_OPERATION;
64 }
65 EC_POINT *newPubKey = EC_POINT_dup(pubKey, group);
66 if (newPubKey == NULL) {
67 LOGE("copy pubKey fail.");
68 EC_KEY_free(ecKey);
69 return HCF_ERR_CRYPTO_OPERATION;
70 }
71 BIGNUM *newPriKey = BN_dup(priKey);
72 if (newPriKey == NULL) {
73 LOGE("copy priKey fail.");
74 EC_KEY_free(ecKey);
75 EC_POINT_free(newPubKey);
76 return HCF_ERR_CRYPTO_OPERATION;
77 }
78
79 *returnPubKey = newPubKey;
80 *returnPriKey = newPriKey;
81 EC_KEY_free(ecKey);
82 return HCF_SUCCESS;
83 }
84
85 // export interfaces
GetEccKeyPairGeneratorClass(void)86 static const char *GetEccKeyPairGeneratorClass(void)
87 {
88 return OPENSSL_ECC_KEY_GENERATOR_CLASS;
89 }
90
GetEccKeyPairClass(void)91 static const char *GetEccKeyPairClass(void)
92 {
93 return HCF_OPENSSL_ECC_KEY_PAIR_CLASS;
94 }
95
GetEccPubKeyClass(void)96 static const char *GetEccPubKeyClass(void)
97 {
98 return HCF_OPENSSL_ECC_PUB_KEY_CLASS;
99 }
100
GetEccPriKeyClass(void)101 static const char *GetEccPriKeyClass(void)
102 {
103 return HCF_OPENSSL_ECC_PRI_KEY_CLASS;
104 }
105
DestroyEccKeyPairGenerator(HcfObjectBase * self)106 static void DestroyEccKeyPairGenerator(HcfObjectBase *self)
107 {
108 if (self == NULL) {
109 return;
110 }
111 if (!IsClassMatch(self, GetEccKeyPairGeneratorClass())) {
112 return;
113 }
114 HcfFree(self);
115 }
116
DestroyEccPubKey(HcfObjectBase * self)117 static void DestroyEccPubKey(HcfObjectBase *self)
118 {
119 if (self == NULL) {
120 return;
121 }
122 if (!IsClassMatch(self, GetEccPubKeyClass())) {
123 return;
124 }
125 HcfOpensslEccPubKey *impl = (HcfOpensslEccPubKey *)self;
126 EC_POINT_free(impl->pk);
127 impl->pk = NULL;
128 HcfFree(impl);
129 }
130
DestroyEccPriKey(HcfObjectBase * self)131 static void DestroyEccPriKey(HcfObjectBase *self)
132 {
133 if (self == NULL) {
134 return;
135 }
136 if (!IsClassMatch(self, GetEccPriKeyClass())) {
137 return;
138 }
139 HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self;
140 BN_clear_free(impl->sk);
141 impl->sk = NULL;
142 HcfFree(impl);
143 }
144
DestroyEccKeyPair(HcfObjectBase * self)145 static void DestroyEccKeyPair(HcfObjectBase *self)
146 {
147 if (self == NULL) {
148 return;
149 }
150 if (!IsClassMatch(self, GetEccKeyPairClass())) {
151 return;
152 }
153 HcfOpensslEccKeyPair *impl = (HcfOpensslEccKeyPair *)self;
154 if (impl->base.pubKey != NULL) {
155 DestroyEccPubKey((HcfObjectBase *)impl->base.pubKey);
156 impl->base.pubKey = NULL;
157 }
158 if (impl->base.priKey != NULL) {
159 DestroyEccPriKey((HcfObjectBase *)impl->base.priKey);
160 impl->base.priKey = NULL;
161 }
162 HcfFree(impl);
163 }
164
DestroyKey(HcfObjectBase * self)165 static void DestroyKey(HcfObjectBase *self)
166 {
167 LOGI("Process DestroyKey");
168 }
169
GetEccPubKeyAlgorithm(HcfKey * self)170 static const char *GetEccPubKeyAlgorithm(HcfKey *self)
171 {
172 if (self == NULL) {
173 LOGE("Invalid input parameter.");
174 return NULL;
175 }
176 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PUB_KEY_CLASS)) {
177 return NULL;
178 }
179 return OPENSSL_ECC_ALGORITHM;
180 }
181
GetEccPriKeyAlgorithm(HcfKey * self)182 static const char *GetEccPriKeyAlgorithm(HcfKey *self)
183 {
184 if (self == NULL) {
185 LOGE("Invalid input parameter.");
186 return NULL;
187 }
188 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PRI_KEY_CLASS)) {
189 return NULL;
190 }
191 return OPENSSL_ECC_ALGORITHM;
192 }
193
GetEccPubKeyFormat(HcfKey * self)194 static const char *GetEccPubKeyFormat(HcfKey *self)
195 {
196 if (self == NULL) {
197 LOGE("Invalid input parameter.");
198 return NULL;
199 }
200 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PUB_KEY_CLASS)) {
201 return NULL;
202 }
203 return OPENSSL_ECC_PUB_KEY_FORMAT;
204 }
205
GetEccPriKeyFormat(HcfKey * self)206 static const char *GetEccPriKeyFormat(HcfKey *self)
207 {
208 if (self == NULL) {
209 LOGE("Invalid input parameter.");
210 return NULL;
211 }
212 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PRI_KEY_CLASS)) {
213 return NULL;
214 }
215 return OPENSSL_ECC_PRI_KEY_FORMAT;
216 }
217
GetEccPubKeyEncoded(HcfKey * self,HcfBlob * returnBlob)218 static HcfResult GetEccPubKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
219 {
220 LOGI("start ...");
221 if ((self == NULL) || (returnBlob == NULL)) {
222 LOGE("Invalid input parameter.");
223 return HCF_INVALID_PARAMS;
224 }
225 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PUB_KEY_CLASS)) {
226 return HCF_INVALID_PARAMS;
227 }
228
229 HcfOpensslEccPubKey *impl = (HcfOpensslEccPubKey *)self;
230 if (impl->pk == NULL) {
231 LOGE("Empty public key!");
232 return HCF_INVALID_PARAMS;
233 }
234 EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId);
235 if (ecKey == NULL) {
236 LOGE("EC_KEY_new_by_curve_name fail.");
237 HcfPrintOpensslError();
238 return HCF_ERR_CRYPTO_OPERATION;
239 }
240 if (EC_KEY_set_public_key(ecKey, impl->pk) <= 0) {
241 LOGE("EC_KEY_set_public_key fail.");
242 HcfPrintOpensslError();
243 EC_KEY_free(ecKey);
244 return HCF_ERR_CRYPTO_OPERATION;
245 }
246 unsigned char *returnData = NULL;
247 int returnDataLen = i2d_EC_PUBKEY(ecKey, &returnData);
248 EC_KEY_free(ecKey);
249 if (returnDataLen <= 0) {
250 LOGE("i2d_EC_PUBKEY fail");
251 HcfPrintOpensslError();
252 return HCF_ERR_CRYPTO_OPERATION;
253 }
254 returnBlob->data = returnData;
255 returnBlob->len = returnDataLen;
256 LOGI("end ...");
257 return HCF_SUCCESS;
258 }
259
GetEccPriKeyEncoded(HcfKey * self,HcfBlob * returnBlob)260 static HcfResult GetEccPriKeyEncoded(HcfKey *self, HcfBlob *returnBlob)
261 {
262 LOGI("start ...");
263 if ((self == NULL) || (returnBlob == NULL)) {
264 LOGE("Invalid input parameter.");
265 return HCF_INVALID_PARAMS;
266 }
267 if (!IsClassMatch((HcfObjectBase *)self, HCF_OPENSSL_ECC_PRI_KEY_CLASS)) {
268 return HCF_INVALID_PARAMS;
269 }
270
271 HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self;
272 if (impl->sk == NULL) {
273 LOGE("Empty private key!");
274 return HCF_INVALID_PARAMS;
275 }
276
277 EC_KEY *ecKey = EC_KEY_new_by_curve_name(impl->curveId);
278 if (ecKey == NULL) {
279 LOGE("EC_KEY_new_by_curve_name fail.");
280 HcfPrintOpensslError();
281 return HCF_ERR_CRYPTO_OPERATION;
282 }
283 if (EC_KEY_set_private_key(ecKey, (impl->sk)) != HCF_OPENSSL_SUCCESS) {
284 LOGE("EC_KEY_set_private_key fail.");
285 HcfPrintOpensslError();
286 EC_KEY_free(ecKey);
287 return HCF_ERR_CRYPTO_OPERATION;
288 }
289 EC_KEY_set_asn1_flag(ecKey, OPENSSL_EC_NAMED_CURVE);
290 EC_KEY_set_enc_flags(ecKey, EC_PKEY_NO_PUBKEY);
291 unsigned char *returnData = NULL;
292 int returnDataLen = i2d_ECPrivateKey(ecKey, &returnData);
293 EC_KEY_free(ecKey);
294 if (returnDataLen <= 0) {
295 LOGE("i2d_ECPrivateKey fail.");
296 HcfPrintOpensslError();
297 return HCF_ERR_CRYPTO_OPERATION;
298 }
299 returnBlob->data = returnData;
300 returnBlob->len = returnDataLen;
301 LOGI("end ...");
302 return HCF_SUCCESS;
303 }
304
EccPriKeyClearMem(HcfPriKey * self)305 static void EccPriKeyClearMem(HcfPriKey *self)
306 {
307 if (self == NULL) {
308 return;
309 }
310 if (!IsClassMatch((HcfObjectBase *)self, GetEccPriKeyClass())) {
311 return;
312 }
313 HcfOpensslEccPriKey *impl = (HcfOpensslEccPriKey *)self;
314 BN_clear(impl->sk);
315 }
316
CreateEccPubKey(int32_t curveId,EC_POINT * pubKey,HcfOpensslEccPubKey ** returnObj)317 static HcfResult CreateEccPubKey(int32_t curveId, EC_POINT *pubKey, HcfOpensslEccPubKey **returnObj)
318 {
319 HcfOpensslEccPubKey *returnPubKey = (HcfOpensslEccPubKey *)HcfMalloc(sizeof(HcfOpensslEccPubKey), 0);
320 if (returnPubKey == NULL) {
321 LOGE("Failed to allocate returnPubKey memory!");
322 return HCF_ERR_MALLOC;
323 }
324 returnPubKey->base.base.base.destroy = DestroyKey;
325 returnPubKey->base.base.base.getClass = GetEccPubKeyClass;
326 returnPubKey->base.base.getAlgorithm = GetEccPubKeyAlgorithm;
327 returnPubKey->base.base.getEncoded = GetEccPubKeyEncoded;
328 returnPubKey->base.base.getFormat = GetEccPubKeyFormat;
329 returnPubKey->curveId = curveId;
330 returnPubKey->pk = pubKey;
331
332 *returnObj = returnPubKey;
333 return HCF_SUCCESS;
334 }
335
CreateEccPriKey(int32_t curveId,BIGNUM * priKey,HcfOpensslEccPriKey ** returnObj)336 static HcfResult CreateEccPriKey(int32_t curveId, BIGNUM *priKey, HcfOpensslEccPriKey **returnObj)
337 {
338 HcfOpensslEccPriKey *returnPriKey = (HcfOpensslEccPriKey *)HcfMalloc(sizeof(HcfOpensslEccPriKey), 0);
339 if (returnPriKey == NULL) {
340 LOGE("Failed to allocate returnPriKey memory!");
341 return HCF_ERR_MALLOC;
342 }
343 returnPriKey->base.base.base.destroy = DestroyKey;
344 returnPriKey->base.base.base.getClass = GetEccPriKeyClass;
345 returnPriKey->base.base.getAlgorithm = GetEccPriKeyAlgorithm;
346 returnPriKey->base.base.getEncoded = GetEccPriKeyEncoded;
347 returnPriKey->base.base.getFormat = GetEccPriKeyFormat;
348 returnPriKey->base.clearMem = EccPriKeyClearMem;
349 returnPriKey->curveId = curveId;
350 returnPriKey->sk = priKey;
351
352 *returnObj = returnPriKey;
353 return HCF_SUCCESS;
354 }
355
CreateEccKeyPair(HcfOpensslEccPubKey * pubKey,HcfOpensslEccPriKey * priKey,HcfOpensslEccKeyPair ** returnObj)356 static HcfResult CreateEccKeyPair(HcfOpensslEccPubKey *pubKey, HcfOpensslEccPriKey *priKey,
357 HcfOpensslEccKeyPair **returnObj)
358 {
359 HcfOpensslEccKeyPair *returnKeyPair = (HcfOpensslEccKeyPair *)HcfMalloc(sizeof(HcfOpensslEccKeyPair), 0);
360 if (returnKeyPair == NULL) {
361 LOGE("Failed to allocate returnKeyPair memory!");
362 return HCF_ERR_MALLOC;
363 }
364 returnKeyPair->base.base.getClass = GetEccKeyPairClass;
365 returnKeyPair->base.base.destroy = DestroyEccKeyPair;
366 returnKeyPair->base.pubKey = (HcfPubKey *)pubKey;
367 returnKeyPair->base.priKey = (HcfPriKey *)priKey;
368
369 *returnObj = returnKeyPair;
370 return HCF_SUCCESS;
371 }
372
ConvertEcPubKeyByOpenssl(int32_t curveId,HcfBlob * pubKeyBlob,HcfOpensslEccPubKey ** returnPubKey)373 static HcfResult ConvertEcPubKeyByOpenssl(int32_t curveId, HcfBlob *pubKeyBlob, HcfOpensslEccPubKey **returnPubKey)
374 {
375 const unsigned char *tmpData = (const unsigned char *)(pubKeyBlob->data);
376 EC_KEY *ecKey = d2i_EC_PUBKEY(NULL, &tmpData, pubKeyBlob->len);
377 if (ecKey == NULL) {
378 LOGE("d2i_EC_PUBKEY fail.");
379 HcfPrintOpensslError();
380 return HCF_ERR_CRYPTO_OPERATION;
381 }
382 const EC_POINT *pubKey = EC_KEY_get0_public_key(ecKey);
383 const EC_GROUP *group = EC_KEY_get0_group(ecKey);
384 if (pubKey == NULL || group == NULL) {
385 LOGE("ec key is invalid.");
386 HcfPrintOpensslError();
387 EC_KEY_free(ecKey);
388 return HCF_ERR_CRYPTO_OPERATION;
389 }
390 EC_POINT *newPubKey = EC_POINT_dup(pubKey, group);
391 EC_KEY_free(ecKey);
392 if (newPubKey == NULL) {
393 LOGE("copy pubKey fail.");
394 return HCF_ERR_CRYPTO_OPERATION;
395 }
396 int32_t res = CreateEccPubKey(curveId, newPubKey, returnPubKey);
397 if (res != HCF_SUCCESS) {
398 EC_POINT_free(newPubKey);
399 return res;
400 }
401 return HCF_SUCCESS;
402 }
403
ConvertEcPriKeyByOpenssl(int32_t curveId,HcfBlob * priKeyBlob,HcfOpensslEccPriKey ** returnPriKey)404 static HcfResult ConvertEcPriKeyByOpenssl(int32_t curveId, HcfBlob *priKeyBlob, HcfOpensslEccPriKey **returnPriKey)
405 {
406 const unsigned char *tmpData = (const unsigned char *)(priKeyBlob->data);
407 EC_KEY *ecKey = d2i_ECPrivateKey(NULL, &tmpData, priKeyBlob->len);
408 if (ecKey == NULL) {
409 LOGE("d2i_ECPrivateKey fail");
410 HcfPrintOpensslError();
411 return HCF_ERR_CRYPTO_OPERATION;
412 }
413 const BIGNUM *priKey = EC_KEY_get0_private_key(ecKey);
414 if (priKey == NULL) {
415 LOGE("ec key is invalid.");
416 HcfPrintOpensslError();
417 EC_KEY_free(ecKey);
418 return HCF_ERR_CRYPTO_OPERATION;
419 }
420 BIGNUM *newPriKey = BN_dup(priKey);
421 EC_KEY_free(ecKey);
422 if (newPriKey == NULL) {
423 LOGE("copy priKey fail.");
424 return HCF_ERR_CRYPTO_OPERATION;
425 }
426 int32_t res = CreateEccPriKey(curveId, newPriKey, returnPriKey);
427 if (res != HCF_SUCCESS) {
428 BN_clear_free(newPriKey);
429 return res;
430 }
431 return HCF_SUCCESS;
432 }
433
EngineConvertEccKey(HcfAsyKeyGeneratorSpi * self,HcfParamsSpec * params,HcfBlob * pubKeyBlob,HcfBlob * priKeyBlob,HcfKeyPair ** returnKeyPair)434 static HcfResult EngineConvertEccKey(HcfAsyKeyGeneratorSpi *self, HcfParamsSpec *params, HcfBlob *pubKeyBlob,
435 HcfBlob *priKeyBlob, HcfKeyPair **returnKeyPair)
436 {
437 LOGI("start ...");
438 (void)params;
439 if ((self == NULL) || (returnKeyPair == NULL)) {
440 LOGE("Invalid input parameter.");
441 return HCF_INVALID_PARAMS;
442 }
443 if (!IsClassMatch((HcfObjectBase *)self, GetEccKeyPairGeneratorClass())) {
444 return HCF_INVALID_PARAMS;
445 }
446 bool pubKeyValid = IsBlobValid(pubKeyBlob);
447 bool priKeyValid = IsBlobValid(priKeyBlob);
448 if ((!pubKeyValid) && (!priKeyValid)) {
449 LOGE("The private key and public key cannot both be NULL.");
450 return HCF_INVALID_PARAMS;
451 }
452
453 HcfAsyKeyGeneratorSpiOpensslEccImpl *impl = (HcfAsyKeyGeneratorSpiOpensslEccImpl *)self;
454 int32_t res = HCF_SUCCESS;
455 HcfOpensslEccPubKey *pubKey = NULL;
456 HcfOpensslEccPriKey *priKey = NULL;
457 HcfOpensslEccKeyPair *keyPair = NULL;
458 do {
459 if (pubKeyValid) {
460 res = ConvertEcPubKeyByOpenssl(impl->curveId, pubKeyBlob, &pubKey);
461 if (res != HCF_SUCCESS) {
462 break;
463 }
464 }
465 if (priKeyValid) {
466 res = ConvertEcPriKeyByOpenssl(impl->curveId, priKeyBlob, &priKey);
467 if (res != HCF_SUCCESS) {
468 break;
469 }
470 }
471 res = CreateEccKeyPair(pubKey, priKey, &keyPair);
472 } while (0);
473 if (res != HCF_SUCCESS) {
474 HcfObjDestroy(pubKey);
475 HcfObjDestroy(priKey);
476 return res;
477 }
478
479 *returnKeyPair = (HcfKeyPair *)keyPair;
480 LOGI("end ...");
481 return HCF_SUCCESS;
482 }
483
EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi * self,HcfKeyPair ** returnObj)484 static HcfResult EngineGenerateKeyPair(HcfAsyKeyGeneratorSpi *self, HcfKeyPair **returnObj)
485 {
486 LOGI("start ...");
487 if ((self == NULL) || (returnObj == NULL)) {
488 LOGE("Invalid input parameter.");
489 return HCF_INVALID_PARAMS;
490 }
491 if (!IsClassMatch((HcfObjectBase *)self, GetEccKeyPairGeneratorClass())) {
492 return HCF_INVALID_PARAMS;
493 }
494
495 HcfAsyKeyGeneratorSpiOpensslEccImpl *impl = (HcfAsyKeyGeneratorSpiOpensslEccImpl *)self;
496 EC_POINT *ecPubKey = NULL;
497 BIGNUM *ecPriKey = NULL;
498 int32_t res = NewEcKeyPairByOpenssl(impl->curveId, &ecPubKey, &ecPriKey);
499 if (res != HCF_SUCCESS) {
500 return res;
501 }
502 HcfOpensslEccPubKey *pubKey = NULL;
503 res = CreateEccPubKey(impl->curveId, ecPubKey, &pubKey);
504 if (res != HCF_SUCCESS) {
505 EC_POINT_free(ecPubKey);
506 BN_clear_free(ecPriKey);
507 return res;
508 }
509 HcfOpensslEccPriKey *priKey = NULL;
510 res = CreateEccPriKey(impl->curveId, ecPriKey, &priKey);
511 if (res != HCF_SUCCESS) {
512 HcfObjDestroy(pubKey);
513 BN_clear_free(ecPriKey);
514 return res;
515 }
516 HcfOpensslEccKeyPair *returnKeyPair = (HcfOpensslEccKeyPair *)HcfMalloc(sizeof(HcfOpensslEccKeyPair), 0);
517 if (returnKeyPair == NULL) {
518 LOGE("Failed to allocate returnKeyPair memory!");
519 HcfObjDestroy(pubKey);
520 HcfObjDestroy(priKey);
521 return HCF_ERR_MALLOC;
522 }
523 returnKeyPair->base.base.getClass = GetEccKeyPairClass;
524 returnKeyPair->base.base.destroy = DestroyEccKeyPair;
525 returnKeyPair->base.pubKey = (HcfPubKey *)pubKey;
526 returnKeyPair->base.priKey = (HcfPriKey *)priKey;
527
528 *returnObj = (HcfKeyPair *)returnKeyPair;
529 LOGI("end ...");
530 return HCF_SUCCESS;
531 }
532
HcfAsyKeyGeneratorSpiEccCreate(HcfAsyKeyGenParams * params,HcfAsyKeyGeneratorSpi ** returnObj)533 HcfResult HcfAsyKeyGeneratorSpiEccCreate(HcfAsyKeyGenParams *params, HcfAsyKeyGeneratorSpi **returnObj)
534 {
535 if (params == NULL || returnObj == NULL) {
536 LOGE("Invalid input parameter.");
537 return HCF_INVALID_PARAMS;
538 }
539 int32_t curveId;
540 if (GetOpensslCurveId(params->bits, &curveId) != HCF_SUCCESS) {
541 return HCF_INVALID_PARAMS;
542 }
543 HcfAsyKeyGeneratorSpiOpensslEccImpl *returnImpl = (HcfAsyKeyGeneratorSpiOpensslEccImpl *)HcfMalloc(
544 sizeof(HcfAsyKeyGeneratorSpiOpensslEccImpl), 0);
545 if (returnImpl == NULL) {
546 LOGE("Failed to allocate returnImpl memroy!");
547 return HCF_ERR_MALLOC;
548 }
549 returnImpl->base.base.getClass = GetEccKeyPairGeneratorClass;
550 returnImpl->base.base.destroy = DestroyEccKeyPairGenerator;
551 returnImpl->base.engineConvertKey = EngineConvertEccKey;
552 returnImpl->base.engineGenerateKeyPair = EngineGenerateKeyPair;
553 returnImpl->curveId = curveId;
554
555 *returnObj = (HcfAsyKeyGeneratorSpi *)returnImpl;
556 return HCF_SUCCESS;
557 }
558