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 "openssl_common.h"
17
18 #include "securec.h"
19
20 #include <string.h>
21 #include <openssl/err.h>
22 #include "config.h"
23 #include "log.h"
24 #include "memory.h"
25 #include "openssl_adapter.h"
26 #include "result.h"
27 #include "params_parser.h"
28 #include "utils.h"
29
30 #define HCF_OPENSSL_DIGEST_NONE_STR "NONE"
31 #define HCF_OPENSSL_DIGEST_MD5_STR "MD5"
32 #define HCF_OPENSSL_DIGEST_SM3_STR "SM3"
33 #define HCF_OPENSSL_DIGEST_SHA1_STR "SHA1"
34 #define HCF_OPENSSL_DIGEST_SHA224_STR "SHA224"
35 #define HCF_OPENSSL_DIGEST_SHA256_STR "SHA256"
36 #define HCF_OPENSSL_DIGEST_SHA384_STR "SHA384"
37 #define HCF_OPENSSL_DIGEST_SHA512_STR "SHA512"
38 #define HCF_OPENSSL_MGF1 "MGF1"
39
40 static const uint32_t ASCII_CODE_ZERO = 48;
41
42 typedef struct {
43 int32_t bits; // keyLen
44 int32_t nid; // nid
45 char *groupName;
46 } NidTypeAlg;
47
48 static const NidTypeAlg NID_TYPE_MAP[] = {
49 { HCF_ALG_ECC_224, NID_secp224r1, "secp224r1" },
50 { HCF_ALG_ECC_256, NID_X9_62_prime256v1, "prime256v1" },
51 { HCF_ALG_ECC_384, NID_secp384r1, "secp384r1" },
52 { HCF_ALG_ECC_521, NID_secp521r1, "secp521r1" },
53 { HCF_ALG_SM2_256, NID_sm2, "sm2" },
54 { HCF_ALG_ECC_BP160R1, NID_brainpoolP160r1, "brainpoolP160r1" },
55 { HCF_ALG_ECC_BP160T1, NID_brainpoolP160t1, "brainpoolP160t1" },
56 { HCF_ALG_ECC_BP192R1, NID_brainpoolP192r1, "brainpoolP192r1" },
57 { HCF_ALG_ECC_BP192T1, NID_brainpoolP192t1, "brainpoolP192t1" },
58 { HCF_ALG_ECC_BP224R1, NID_brainpoolP224r1, "brainpoolP224r1" },
59 { HCF_ALG_ECC_BP224T1, NID_brainpoolP224t1, "brainpoolP224t1" },
60 { HCF_ALG_ECC_BP256R1, NID_brainpoolP256r1, "brainpoolP256r1" },
61 { HCF_ALG_ECC_BP256T1, NID_brainpoolP256t1, "brainpoolP256t1" },
62 { HCF_ALG_ECC_BP320R1, NID_brainpoolP320r1, "brainpoolP320r1" },
63 { HCF_ALG_ECC_BP320T1, NID_brainpoolP320t1, "brainpoolP320t1" },
64 { HCF_ALG_ECC_BP384R1, NID_brainpoolP384r1, "brainpoolP384r1" },
65 { HCF_ALG_ECC_BP384T1, NID_brainpoolP384t1, "brainpoolP384t1" },
66 { HCF_ALG_ECC_BP512R1, NID_brainpoolP512r1, "brainpoolP512r1" },
67 { HCF_ALG_ECC_BP512T1, NID_brainpoolP512t1, "brainpoolP512t1" },
68 };
69
70 typedef struct {
71 int32_t curveId;
72 char *curveName;
73 } CurveNameAlg;
74
75 static const CurveNameAlg CURVE_NAME_MAP[] = {
76 { NID_secp224r1, "NID_secp224r1" },
77 { NID_X9_62_prime256v1, "NID_X9_62_prime256v1" },
78 { NID_secp384r1, "NID_secp384r1" },
79 { NID_secp521r1, "NID_secp521r1" },
80 { NID_brainpoolP160r1, "NID_brainpoolP160r1" },
81 { NID_brainpoolP160t1, "NID_brainpoolP160t1" },
82 { NID_brainpoolP192r1, "NID_brainpoolP192r1" },
83 { NID_brainpoolP192t1, "NID_brainpoolP192t1" },
84 { NID_brainpoolP224r1, "NID_brainpoolP224r1" },
85 { NID_brainpoolP224t1, "NID_brainpoolP224t1" },
86 { NID_brainpoolP256r1, "NID_brainpoolP256r1" },
87 { NID_brainpoolP256t1, "NID_brainpoolP256t1" },
88 { NID_brainpoolP320r1, "NID_brainpoolP320r1" },
89 { NID_brainpoolP320t1, "NID_brainpoolP320t1" },
90 { NID_brainpoolP384r1, "NID_brainpoolP384r1" },
91 { NID_brainpoolP384t1, "NID_brainpoolP384t1" },
92 { NID_brainpoolP512r1, "NID_brainpoolP512r1" },
93 { NID_brainpoolP512t1, "NID_brainpoolP512t1" }
94 };
95
96 typedef struct {
97 int32_t bits;
98 char *algName;
99 } AlgNameType;
100
101 static const AlgNameType ALG_NAME_TYPE_MAP[] = {
102 { HCF_ALG_ECC_224, "ECC" },
103 { HCF_ALG_ECC_256, "ECC" },
104 { HCF_ALG_ECC_384, "ECC" },
105 { HCF_ALG_ECC_521, "ECC" },
106 { HCF_ALG_SM2_256, "SM2" },
107 { HCF_ALG_ECC_BP160R1, "ECC" },
108 { HCF_ALG_ECC_BP160T1, "ECC" },
109 { HCF_ALG_ECC_BP192R1, "ECC" },
110 { HCF_ALG_ECC_BP192T1, "ECC" },
111 { HCF_ALG_ECC_BP224R1, "ECC" },
112 { HCF_ALG_ECC_BP224T1, "ECC" },
113 { HCF_ALG_ECC_BP256R1, "ECC" },
114 { HCF_ALG_ECC_BP256T1, "ECC" },
115 { HCF_ALG_ECC_BP320R1, "ECC" },
116 { HCF_ALG_ECC_BP320T1, "ECC" },
117 { HCF_ALG_ECC_BP384R1, "ECC" },
118 { HCF_ALG_ECC_BP384T1, "ECC" },
119 { HCF_ALG_ECC_BP512R1, "ECC" },
120 { HCF_ALG_ECC_BP512T1, "ECC" }
121 };
122
123 typedef struct {
124 int32_t formatValue;
125 int32_t formatType;
126 } FormatType;
127
128 static const FormatType FORMAT_TYPE_MAP[] = {
129 { HCF_UNCOMPRESSED_FORMAT_VALUE, POINT_CONVERSION_UNCOMPRESSED },
130 { HCF_COMPRESSED_FORMAT_VALUE, POINT_CONVERSION_COMPRESSED }
131 };
132
GetCurveNameByCurveId(int32_t curveId,char ** curveName)133 HcfResult GetCurveNameByCurveId(int32_t curveId, char **curveName)
134 {
135 if (curveName == NULL) {
136 LOGE("Invalid curveName");
137 return HCF_INVALID_PARAMS;
138 }
139 for (uint32_t i = 0; i < sizeof(CURVE_NAME_MAP) / sizeof(CURVE_NAME_MAP[0]); i++) {
140 if (CURVE_NAME_MAP[i].curveId == curveId) {
141 *curveName = CURVE_NAME_MAP[i].curveName;
142 return HCF_SUCCESS;
143 }
144 }
145 LOGE("Invalid curve id:%d", curveId);
146 return HCF_INVALID_PARAMS;
147 }
148
GetNidByCurveNameValue(int32_t curveNameValue,int32_t * nid)149 HcfResult GetNidByCurveNameValue(int32_t curveNameValue, int32_t *nid)
150 {
151 if (nid == NULL) {
152 LOGE("Invalid nid");
153 return HCF_INVALID_PARAMS;
154 }
155 for (uint32_t i = 0; i < sizeof(NID_TYPE_MAP) / sizeof(NID_TYPE_MAP[0]); i++) {
156 if (NID_TYPE_MAP[i].bits == curveNameValue) {
157 *nid = NID_TYPE_MAP[i].nid;
158 return HCF_SUCCESS;
159 }
160 }
161 LOGE("Invalid curveNameValue value: %d", curveNameValue);
162 return HCF_INVALID_PARAMS;
163 }
164
GetGroupNameByNid(int32_t nid,char ** groupName)165 HcfResult GetGroupNameByNid(int32_t nid, char **groupName)
166 {
167 if (groupName == NULL) {
168 LOGE("Invalid groupName");
169 return HCF_INVALID_PARAMS;
170 }
171 for (uint32_t i = 0; i < sizeof(NID_TYPE_MAP) / sizeof(NID_TYPE_MAP[0]); i++) {
172 if (NID_TYPE_MAP[i].nid == nid) {
173 *groupName = NID_TYPE_MAP[i].groupName;
174 return HCF_SUCCESS;
175 }
176 }
177 LOGE("Invalid nid:%d", nid);
178 return HCF_INVALID_PARAMS;
179 }
180
GetFormatTypeByFormatValue(int32_t formatValue,int32_t * formatType)181 HcfResult GetFormatTypeByFormatValue(int32_t formatValue, int32_t *formatType)
182 {
183 if (formatType == NULL) {
184 LOGE("Invalid formatType");
185 return HCF_INVALID_PARAMS;
186 }
187 for (uint32_t i = 0; i < sizeof(FORMAT_TYPE_MAP) / sizeof(FORMAT_TYPE_MAP[0]); i++) {
188 if (FORMAT_TYPE_MAP[i].formatValue == formatValue) {
189 *formatType = FORMAT_TYPE_MAP[i].formatType;
190 return HCF_SUCCESS;
191 }
192 }
193 LOGE("Invalid format value: %d", formatValue);
194 return HCF_INVALID_PARAMS;
195 }
196
GetAlgNameByBits(int32_t keyLen,char ** algName)197 HcfResult GetAlgNameByBits(int32_t keyLen, char **algName)
198 {
199 if (algName == NULL) {
200 LOGE("Invalid algName");
201 return HCF_INVALID_PARAMS;
202 }
203 for (uint32_t i = 0; i < sizeof(ALG_NAME_TYPE_MAP) / sizeof(ALG_NAME_TYPE_MAP[0]); i++) {
204 if (ALG_NAME_TYPE_MAP[i].bits == keyLen) {
205 size_t srcAlgNameLen = HcfStrlen(ALG_NAME_TYPE_MAP[i].algName);
206 if (srcAlgNameLen == 0) {
207 LOGE("algName is empty!");
208 return HCF_ERR_MALLOC;
209 }
210 *algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0);
211 if (*algName == NULL) {
212 LOGE("algName malloc failed.");
213 return HCF_ERR_MALLOC;
214 }
215 if (memcpy_s(*algName, srcAlgNameLen, ALG_NAME_TYPE_MAP[i].algName, srcAlgNameLen) != EOK) {
216 LOGE("memcpy algName failed.");
217 HcfFree(*algName);
218 *algName = NULL;
219 return HCF_ERR_MALLOC;
220 }
221 return HCF_SUCCESS;
222 }
223 }
224 LOGD("[error] Invalid key size:%d", keyLen);
225 return HCF_INVALID_PARAMS;
226 }
227
GetOpensslCurveId(int32_t keyLen,int32_t * returnCurveId)228 HcfResult GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId)
229 {
230 if (returnCurveId == NULL) {
231 LOGE("Invalid algName");
232 return HCF_INVALID_PARAMS;
233 }
234 for (uint32_t i = 0; i < sizeof(NID_TYPE_MAP) / sizeof(NID_TYPE_MAP[0]); i++) {
235 if (NID_TYPE_MAP[i].bits == keyLen) {
236 *returnCurveId = NID_TYPE_MAP[i].nid;
237 return HCF_SUCCESS;
238 }
239 }
240 LOGE("invalid key size:%d", keyLen);
241 return HCF_INVALID_PARAMS;
242 }
243
GetOpensslDigestAlg(uint32_t alg,EVP_MD ** digestAlg)244 HcfResult GetOpensslDigestAlg(uint32_t alg, EVP_MD **digestAlg)
245 {
246 if (digestAlg == NULL) {
247 LOGE("Invalid MD pointer");
248 return HCF_INVALID_PARAMS;
249 }
250 switch (alg) {
251 case HCF_OPENSSL_DIGEST_NONE:
252 *digestAlg = NULL;
253 break;
254 case HCF_OPENSSL_DIGEST_MD5:
255 *digestAlg = (EVP_MD *)EVP_md5();
256 break;
257 case HCF_OPENSSL_DIGEST_SM3:
258 *digestAlg = (EVP_MD *)EVP_sm3();
259 break;
260 case HCF_OPENSSL_DIGEST_SHA1:
261 *digestAlg = (EVP_MD *)EVP_sha1();
262 break;
263 case HCF_OPENSSL_DIGEST_SHA224:
264 *digestAlg = (EVP_MD *)EVP_sha224();
265 break;
266 case HCF_OPENSSL_DIGEST_SHA256:
267 *digestAlg = (EVP_MD *)EVP_sha256();
268 break;
269 case HCF_OPENSSL_DIGEST_SHA384:
270 *digestAlg = (EVP_MD *)EVP_sha384();
271 break;
272 case HCF_OPENSSL_DIGEST_SHA512:
273 *digestAlg = (EVP_MD *)EVP_sha512();
274 break;
275 default:
276 LOGD("[error] Invalid digest num is %u.", alg);
277 return HCF_INVALID_PARAMS;
278 }
279 return HCF_SUCCESS;
280 }
281
GetRsaSpecStringMd(const HcfAlgParaValue md,char ** returnString)282 HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString)
283 {
284 if (returnString == NULL) {
285 LOGE("return string is null");
286 return HCF_INVALID_PARAMS;
287 }
288 char *tmp = NULL;
289 switch (md) {
290 case HCF_OPENSSL_DIGEST_MD5:
291 tmp = HCF_OPENSSL_DIGEST_MD5_STR;
292 break;
293 case HCF_OPENSSL_DIGEST_SM3:
294 tmp = HCF_OPENSSL_DIGEST_SM3_STR;
295 break;
296 case HCF_OPENSSL_DIGEST_SHA1:
297 tmp = HCF_OPENSSL_DIGEST_SHA1_STR;
298 break;
299 case HCF_OPENSSL_DIGEST_SHA224:
300 tmp = HCF_OPENSSL_DIGEST_SHA224_STR;
301 break;
302 case HCF_OPENSSL_DIGEST_SHA256:
303 tmp = HCF_OPENSSL_DIGEST_SHA256_STR;
304 break;
305 case HCF_OPENSSL_DIGEST_SHA384:
306 tmp = HCF_OPENSSL_DIGEST_SHA384_STR;
307 break;
308 case HCF_OPENSSL_DIGEST_SHA512:
309 tmp = HCF_OPENSSL_DIGEST_SHA512_STR;
310 break;
311 default:
312 LOGE("Invalid digest num is %u.", md);
313 return HCF_INVALID_PARAMS;
314 }
315 size_t mdLen = HcfStrlen(tmp);
316 if (mdLen == 0) {
317 LOGE("mdLen is empty!");
318 return HCF_ERR_MALLOC;
319 }
320 char *mdStr = (char *)HcfMalloc(mdLen + 1, 0);
321 if (mdStr == NULL) {
322 LOGE("Failed to allocate md name memory");
323 return HCF_ERR_MALLOC;
324 }
325 (void)memcpy_s(mdStr, mdLen, tmp, mdLen);
326 *returnString = mdStr;
327 return HCF_SUCCESS;
328 }
329
GetRsaSpecStringMGF(char ** returnString)330 HcfResult GetRsaSpecStringMGF(char **returnString)
331 {
332 if (returnString == NULL) {
333 LOGE("return string is null");
334 return HCF_INVALID_PARAMS;
335 }
336 size_t mgf1Len = HcfStrlen(HCF_OPENSSL_MGF1);
337 if (mgf1Len == 0) {
338 LOGE("mgf1Len is empty!");
339 return HCF_ERR_MALLOC;
340 }
341 char *mgf1Str = (char *)HcfMalloc(mgf1Len + 1, 0);
342 if (mgf1Str == NULL) {
343 LOGE("Failed to allocate mgf1 name memory");
344 return HCF_ERR_MALLOC;
345 }
346 (void)memcpy_s(mgf1Str, mgf1Len, HCF_OPENSSL_MGF1, mgf1Len);
347 *returnString = mgf1Str;
348 return HCF_SUCCESS;
349 }
350
GetSm2SpecStringSm3(char ** returnString)351 HcfResult GetSm2SpecStringSm3(char **returnString)
352 {
353 if (returnString == NULL) {
354 LOGE("return string is null");
355 return HCF_INVALID_PARAMS;
356 }
357 size_t sm2Len = HcfStrlen(HCF_OPENSSL_DIGEST_SM3_STR);
358 if (sm2Len == 0) {
359 LOGE("sm2Len is empty!");
360 return HCF_ERR_MALLOC;
361 }
362 char *sm2Str = (char *)HcfMalloc(sm2Len + 1, 0);
363 if (sm2Str == NULL) {
364 LOGE("Failed to allocate sm2 name memory");
365 return HCF_ERR_MALLOC;
366 }
367 if (memcpy_s(sm2Str, sm2Len, HCF_OPENSSL_DIGEST_SM3_STR, sm2Len) != EOK) {
368 LOGE("memcpy sm2Str failed.");
369 HcfFree(sm2Str);
370 return HCF_ERR_MALLOC;
371 }
372 *returnString = sm2Str;
373 return HCF_SUCCESS;
374 }
375
HcfPrintOpensslError(void)376 void HcfPrintOpensslError(void)
377 {
378 char szErr[LOG_PRINT_MAX_LEN] = {0}; // Then maximum length of the OpenSSL error string is 256.
379 unsigned long errCode;
380
381 errCode = ERR_get_error();
382 ERR_error_string_n(errCode, szErr, LOG_PRINT_MAX_LEN);
383
384 LOGD("[error] [Openssl]: engine fail, error code = %lu, error string = %s", errCode, szErr);
385 }
386
GetOpensslPadding(int32_t padding,int32_t * opensslPadding)387 HcfResult GetOpensslPadding(int32_t padding, int32_t *opensslPadding)
388 {
389 if (opensslPadding == NULL) {
390 LOGE("return openssl padding pointer is null");
391 return HCF_INVALID_PARAMS;
392 }
393 switch (padding) {
394 case HCF_ALG_NOPADDING:
395 *opensslPadding = RSA_NO_PADDING;
396 return HCF_SUCCESS;
397
398 case HCF_OPENSSL_RSA_PKCS1_PADDING:
399 *opensslPadding = RSA_PKCS1_PADDING;
400 return HCF_SUCCESS;
401
402 case HCF_OPENSSL_RSA_PKCS1_OAEP_PADDING:
403 *opensslPadding = RSA_PKCS1_OAEP_PADDING;
404 return HCF_SUCCESS;
405
406 case HCF_OPENSSL_RSA_PSS_PADDING:
407 *opensslPadding = RSA_PKCS1_PSS_PADDING;
408 return HCF_SUCCESS;
409
410 default:
411 LOGD("[error] Invalid framwork padding = %d", padding);
412 return HCF_INVALID_PARAMS;
413 }
414 }
415
IsBigEndian(void)416 bool IsBigEndian(void)
417 {
418 uint32_t *pointer = (uint32_t *)&ASCII_CODE_ZERO;
419 char firstChar = *((char *)pointer);
420 if (firstChar == '0') {
421 return false;
422 } else {
423 return true;
424 }
425 }
426
BigIntegerToBigNum(const HcfBigInteger * src,BIGNUM ** dest)427 HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest)
428 {
429 if (src == NULL || dest == NULL) {
430 LOGE("Invalid input parameter.");
431 return HCF_INVALID_PARAMS;
432 }
433
434 if (IsBigEndian()) {
435 *dest = OpensslBin2Bn((src->data), (src->len), *dest);
436 } else {
437 *dest = OpensslLeBin2Bn((src->data), (src->len), *dest);
438 }
439
440 if (*dest == NULL) {
441 LOGD("[error] translate BigInteger to BIGNUM failed.");
442 HcfPrintOpensslError();
443 return HCF_ERR_CRYPTO_OPERATION;
444 }
445 return HCF_SUCCESS;
446 }
447
BigNumToBigInteger(const BIGNUM * src,HcfBigInteger * dest)448 HcfResult BigNumToBigInteger(const BIGNUM *src, HcfBigInteger *dest)
449 {
450 if (src == NULL || dest == NULL) {
451 LOGE("Invalid input parameter.");
452 return HCF_INVALID_PARAMS;
453 }
454
455 int len = OpensslBnNumBytes(src);
456 if (len <= 0) {
457 LOGD("[error] Invalid input parameter.");
458 HcfPrintOpensslError();
459 return HCF_ERR_CRYPTO_OPERATION;
460 }
461 dest->data = (unsigned char *)HcfMalloc(len, 0);
462 if (dest->data == NULL) {
463 LOGE("Alloc dest->data memeory failed.");
464 return HCF_ERR_MALLOC;
465 }
466 dest->len = len;
467
468 int resLen = -1;
469 if (IsBigEndian()) {
470 resLen = OpensslBn2BinPad(src, dest->data, dest->len);
471 } else {
472 resLen = OpensslBn2LeBinPad(src, dest->data, dest->len);
473 }
474
475 if (resLen != len) {
476 LOGD("[error] translate BIGNUM to BigInteger failed.");
477 HcfPrintOpensslError();
478 HcfFree(dest->data);
479 dest->data = NULL;
480 dest->len = 0;
481 return HCF_ERR_CRYPTO_OPERATION;
482 }
483 return HCF_SUCCESS;
484 }
485
KeyDerive(EVP_PKEY * priKey,EVP_PKEY * pubKey,HcfBlob * returnSecret)486 HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret)
487 {
488 EVP_PKEY_CTX *ctx = OpensslEvpPkeyCtxNew(priKey, NULL);
489 if (ctx == NULL) {
490 LOGD("[error] EVP_PKEY_CTX_new failed!");
491 HcfPrintOpensslError();
492 return HCF_ERR_CRYPTO_OPERATION;
493 }
494 HcfResult ret = HCF_ERR_CRYPTO_OPERATION;
495 do {
496 if (OpensslEvpPkeyDeriveInit(ctx) != HCF_OPENSSL_SUCCESS) {
497 LOGD("[error] Evp key derive init failed!");
498 HcfPrintOpensslError();
499 break;
500 }
501 if (OpensslEvpPkeyDeriveSetPeer(ctx, pubKey) != HCF_OPENSSL_SUCCESS) {
502 LOGD("[error] Evp key derive set peer failed!");
503 HcfPrintOpensslError();
504 break;
505 }
506 size_t maxLen;
507 if (OpensslEvpPkeyDerive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) {
508 LOGD("[error] Evp key derive failed!");
509 HcfPrintOpensslError();
510 break;
511 }
512 uint8_t *secretData = (uint8_t *)HcfMalloc(maxLen, 0);
513 if (secretData == NULL) {
514 LOGE("Failed to allocate secretData memory!");
515 ret = HCF_ERR_MALLOC;
516 break;
517 }
518
519 if (OpensslEvpPkeyDerive(ctx, secretData, &maxLen) != HCF_OPENSSL_SUCCESS) {
520 LOGD("[error] Evp key derive failed!");
521 HcfPrintOpensslError();
522 HcfFree(secretData);
523 break;
524 }
525
526 returnSecret->data = secretData;
527 returnSecret->len = maxLen;
528 ret = HCF_SUCCESS;
529 } while (0);
530 OpensslEvpPkeyCtxFree(ctx);
531 return ret;
532 }
533
GetKeyEncodedPem(EVP_PKEY * pkey,const char * outPutStruct,int selection,char ** returnString)534 HcfResult GetKeyEncodedPem(EVP_PKEY *pkey, const char *outPutStruct, int selection, char **returnString)
535 {
536 OSSL_ENCODER_CTX *ctx = OpensslOsslEncoderCtxNewForPkey(pkey, selection, "PEM", outPutStruct, NULL);
537 if (ctx == NULL) {
538 LOGE("OSSL_ENCODER_CTX_new_for_pkey failed.");
539 HcfPrintOpensslError();
540 return HCF_ERR_CRYPTO_OPERATION;
541 }
542
543 unsigned char *data = NULL;
544 size_t dataLen = 0;
545 if (OpensslOsslEncoderToData(ctx, &data, &dataLen) != HCF_OPENSSL_SUCCESS) {
546 HcfPrintOpensslError();
547 OpensslOsslEncoderCtxFree(ctx);
548 return HCF_ERR_CRYPTO_OPERATION;
549 }
550 *returnString = (char *)data;
551 OpensslOsslEncoderCtxFree(ctx);
552 return HCF_SUCCESS;
553 }
554