1 /*
2 * Copyright (C) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "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 PRIMES_2 2
31 #define PRIMES_3 3
32 #define PRIMES_4 4
33 #define PRIMES_5 5
34
35 #define HCF_OPENSSL_DIGEST_NONE_STR "NONE"
36 #define HCF_OPENSSL_DIGEST_MD5_STR "MD5"
37 #define HCF_OPENSSL_DIGEST_SM3_STR "SM3"
38 #define HCF_OPENSSL_DIGEST_SHA1_STR "SHA1"
39 #define HCF_OPENSSL_DIGEST_SHA224_STR "SHA224"
40 #define HCF_OPENSSL_DIGEST_SHA256_STR "SHA256"
41 #define HCF_OPENSSL_DIGEST_SHA384_STR "SHA384"
42 #define HCF_OPENSSL_DIGEST_SHA512_STR "SHA512"
43 #define HCF_OPENSSL_MGF1 "MGF1"
44
45 static const uint32_t ASCII_CODE_ZERO = 48;
46
47 typedef struct {
48 int32_t bits; // keyLen
49 int32_t nid; // nid
50 } NidTypeAlg;
51
52 static const NidTypeAlg NID_TYPE_MAP[] = {
53 { HCF_ALG_ECC_224, NID_secp224r1 },
54 { HCF_ALG_ECC_256, NID_X9_62_prime256v1 },
55 { HCF_ALG_ECC_384, NID_secp384r1 },
56 { HCF_ALG_ECC_521, NID_secp521r1 },
57 { HCF_ALG_SM2_256, NID_sm2 },
58 { HCF_ALG_ECC_BP160R1, NID_brainpoolP160r1 },
59 { HCF_ALG_ECC_BP160T1, NID_brainpoolP160t1 },
60 { HCF_ALG_ECC_BP192R1, NID_brainpoolP192r1 },
61 { HCF_ALG_ECC_BP192T1, NID_brainpoolP192t1 },
62 { HCF_ALG_ECC_BP224R1, NID_brainpoolP224r1 },
63 { HCF_ALG_ECC_BP224T1, NID_brainpoolP224t1 },
64 { HCF_ALG_ECC_BP256R1, NID_brainpoolP256r1 },
65 { HCF_ALG_ECC_BP256T1, NID_brainpoolP256t1 },
66 { HCF_ALG_ECC_BP320R1, NID_brainpoolP320r1 },
67 { HCF_ALG_ECC_BP320T1, NID_brainpoolP320t1 },
68 { HCF_ALG_ECC_BP384R1, NID_brainpoolP384r1 },
69 { HCF_ALG_ECC_BP384T1, NID_brainpoolP384t1 },
70 { HCF_ALG_ECC_BP512R1, NID_brainpoolP512r1 },
71 { HCF_ALG_ECC_BP512T1, NID_brainpoolP512t1 },
72 };
73
74 typedef struct {
75 int32_t curveId;
76 char *curveName;
77 } CurveNameAlg;
78
79 static const CurveNameAlg CURVE_NAME_MAP[] = {
80 { NID_secp224r1, "NID_secp224r1" },
81 { NID_X9_62_prime256v1, "NID_X9_62_prime256v1" },
82 { NID_secp384r1, "NID_secp384r1" },
83 { NID_secp521r1, "NID_secp521r1" },
84 { NID_brainpoolP160r1, "NID_brainpoolP160r1" },
85 { NID_brainpoolP160t1, "NID_brainpoolP160t1" },
86 { NID_brainpoolP192r1, "NID_brainpoolP192r1" },
87 { NID_brainpoolP192t1, "NID_brainpoolP192t1" },
88 { NID_brainpoolP224r1, "NID_brainpoolP224r1" },
89 { NID_brainpoolP224t1, "NID_brainpoolP224t1" },
90 { NID_brainpoolP256r1, "NID_brainpoolP256r1" },
91 { NID_brainpoolP256t1, "NID_brainpoolP256t1" },
92 { NID_brainpoolP320r1, "NID_brainpoolP320r1" },
93 { NID_brainpoolP320t1, "NID_brainpoolP320t1" },
94 { NID_brainpoolP384r1, "NID_brainpoolP384r1" },
95 { NID_brainpoolP384t1, "NID_brainpoolP384t1" },
96 { NID_brainpoolP512r1, "NID_brainpoolP512r1" },
97 { NID_brainpoolP512t1, "NID_brainpoolP512t1" }
98 };
99
100 typedef struct {
101 int32_t bits;
102 char *algName;
103 } AlgNameType;
104
105 static const AlgNameType ALG_NAME_TYPE_MAP[] = {
106 { HCF_ALG_ECC_224, "ECC" },
107 { HCF_ALG_ECC_256, "ECC" },
108 { HCF_ALG_ECC_384, "ECC" },
109 { HCF_ALG_ECC_521, "ECC" },
110 { HCF_ALG_SM2_256, "SM2" },
111 { HCF_ALG_ECC_BP160R1, "ECC" },
112 { HCF_ALG_ECC_BP160T1, "ECC" },
113 { HCF_ALG_ECC_BP192R1, "ECC" },
114 { HCF_ALG_ECC_BP192T1, "ECC" },
115 { HCF_ALG_ECC_BP224R1, "ECC" },
116 { HCF_ALG_ECC_BP224T1, "ECC" },
117 { HCF_ALG_ECC_BP256R1, "ECC" },
118 { HCF_ALG_ECC_BP256T1, "ECC" },
119 { HCF_ALG_ECC_BP320R1, "ECC" },
120 { HCF_ALG_ECC_BP320T1, "ECC" },
121 { HCF_ALG_ECC_BP384R1, "ECC" },
122 { HCF_ALG_ECC_BP384T1, "ECC" },
123 { HCF_ALG_ECC_BP512R1, "ECC" },
124 { HCF_ALG_ECC_BP512T1, "ECC" }
125 };
126
GetCurveNameByCurveId(int32_t curveId,char ** curveName)127 HcfResult GetCurveNameByCurveId(int32_t curveId, char **curveName)
128 {
129 if (curveName == NULL) {
130 LOGE("Invalid curveName");
131 return HCF_INVALID_PARAMS;
132 }
133 for (uint32_t i = 0; i < sizeof(CURVE_NAME_MAP) / sizeof(CURVE_NAME_MAP[0]); i++) {
134 if (CURVE_NAME_MAP[i].curveId == curveId) {
135 *curveName = CURVE_NAME_MAP[i].curveName;
136 return HCF_SUCCESS;
137 }
138 }
139 LOGD("[error] Invalid curve id:%d", curveId);
140 return HCF_INVALID_PARAMS;
141 }
142
GetAlgNameByBits(int32_t keyLen,char ** algName)143 HcfResult GetAlgNameByBits(int32_t keyLen, char **algName)
144 {
145 if (algName == NULL) {
146 LOGE("Invalid algName");
147 return HCF_INVALID_PARAMS;
148 }
149 for (uint32_t i = 0; i < sizeof(ALG_NAME_TYPE_MAP) / sizeof(ALG_NAME_TYPE_MAP[0]); i++) {
150 if (ALG_NAME_TYPE_MAP[i].bits == keyLen) {
151 size_t srcAlgNameLen = HcfStrlen(ALG_NAME_TYPE_MAP[i].algName);
152 if (srcAlgNameLen == 0) {
153 LOGE("algName is empty!");
154 return HCF_ERR_MALLOC;
155 }
156 *algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0);
157 if (*algName == NULL) {
158 LOGE("algName malloc failed.");
159 return HCF_ERR_MALLOC;
160 }
161 if (memcpy_s(*algName, srcAlgNameLen, ALG_NAME_TYPE_MAP[i].algName, srcAlgNameLen) != EOK) {
162 LOGE("memcpy algName failed.");
163 HcfFree(*algName);
164 *algName = NULL;
165 return HCF_ERR_MALLOC;
166 }
167 return HCF_SUCCESS;
168 }
169 }
170 LOGD("[error] Invalid key size:%d", keyLen);
171 return HCF_INVALID_PARAMS;
172 }
173
GetOpensslCurveId(int32_t keyLen,int32_t * returnCurveId)174 HcfResult GetOpensslCurveId(int32_t keyLen, int32_t *returnCurveId)
175 {
176 if (returnCurveId == NULL) {
177 LOGE("Invalid algName");
178 return HCF_INVALID_PARAMS;
179 }
180 for (uint32_t i = 0; i < sizeof(NID_TYPE_MAP) / sizeof(NID_TYPE_MAP[0]); i++) {
181 if (NID_TYPE_MAP[i].bits == keyLen) {
182 *returnCurveId = NID_TYPE_MAP[i].nid;
183 return HCF_SUCCESS;
184 }
185 }
186 LOGE("invalid key size:%d", keyLen);
187 return HCF_INVALID_PARAMS;
188 }
189
GetOpensslDigestAlg(uint32_t alg,EVP_MD ** digestAlg)190 HcfResult GetOpensslDigestAlg(uint32_t alg, EVP_MD **digestAlg)
191 {
192 if (digestAlg == NULL) {
193 LOGE("Invalid MD pointer");
194 return HCF_INVALID_PARAMS;
195 }
196 switch (alg) {
197 case HCF_OPENSSL_DIGEST_NONE:
198 *digestAlg = NULL;
199 break;
200 case HCF_OPENSSL_DIGEST_MD5:
201 *digestAlg = (EVP_MD *)EVP_md5();
202 break;
203 case HCF_OPENSSL_DIGEST_SM3:
204 *digestAlg = (EVP_MD *)EVP_sm3();
205 break;
206 case HCF_OPENSSL_DIGEST_SHA1:
207 *digestAlg = (EVP_MD *)EVP_sha1();
208 break;
209 case HCF_OPENSSL_DIGEST_SHA224:
210 *digestAlg = (EVP_MD *)EVP_sha224();
211 break;
212 case HCF_OPENSSL_DIGEST_SHA256:
213 *digestAlg = (EVP_MD *)EVP_sha256();
214 break;
215 case HCF_OPENSSL_DIGEST_SHA384:
216 *digestAlg = (EVP_MD *)EVP_sha384();
217 break;
218 case HCF_OPENSSL_DIGEST_SHA512:
219 *digestAlg = (EVP_MD *)EVP_sha512();
220 break;
221 default:
222 LOGD("[error] Invalid digest num is %u.", alg);
223 return HCF_INVALID_PARAMS;
224 }
225 return HCF_SUCCESS;
226 }
227
GetRsaSpecStringMd(const HcfAlgParaValue md,char ** returnString)228 HcfResult GetRsaSpecStringMd(const HcfAlgParaValue md, char **returnString)
229 {
230 if (returnString == NULL) {
231 LOGE("return string is null");
232 return HCF_INVALID_PARAMS;
233 }
234 char *tmp = NULL;
235 switch (md) {
236 case HCF_OPENSSL_DIGEST_MD5:
237 tmp = HCF_OPENSSL_DIGEST_MD5_STR;
238 break;
239 case HCF_OPENSSL_DIGEST_SM3:
240 tmp = HCF_OPENSSL_DIGEST_SM3_STR;
241 break;
242 case HCF_OPENSSL_DIGEST_SHA1:
243 tmp = HCF_OPENSSL_DIGEST_SHA1_STR;
244 break;
245 case HCF_OPENSSL_DIGEST_SHA224:
246 tmp = HCF_OPENSSL_DIGEST_SHA224_STR;
247 break;
248 case HCF_OPENSSL_DIGEST_SHA256:
249 tmp = HCF_OPENSSL_DIGEST_SHA256_STR;
250 break;
251 case HCF_OPENSSL_DIGEST_SHA384:
252 tmp = HCF_OPENSSL_DIGEST_SHA384_STR;
253 break;
254 case HCF_OPENSSL_DIGEST_SHA512:
255 tmp = HCF_OPENSSL_DIGEST_SHA512_STR;
256 break;
257 default:
258 LOGE("Invalid digest num is %u.", md);
259 return HCF_INVALID_PARAMS;
260 }
261 size_t mdLen = HcfStrlen(tmp);
262 if (mdLen == 0) {
263 LOGE("mdLen is empty!");
264 return HCF_ERR_MALLOC;
265 }
266 char *mdStr = (char *)HcfMalloc(mdLen + 1, 0);
267 if (mdStr == NULL) {
268 LOGE("Failed to allocate md name memory");
269 return HCF_ERR_MALLOC;
270 }
271 (void)memcpy_s(mdStr, mdLen, tmp, mdLen);
272 *returnString = mdStr;
273 return HCF_SUCCESS;
274 }
275
GetRsaSpecStringMGF(char ** returnString)276 HcfResult GetRsaSpecStringMGF(char **returnString)
277 {
278 if (returnString == NULL) {
279 LOGE("return string is null");
280 return HCF_INVALID_PARAMS;
281 }
282 size_t mgf1Len = HcfStrlen(HCF_OPENSSL_MGF1);
283 if (mgf1Len == 0) {
284 LOGE("mgf1Len is empty!");
285 return HCF_ERR_MALLOC;
286 }
287 char *mgf1Str = (char *)HcfMalloc(mgf1Len + 1, 0);
288 if (mgf1Str == NULL) {
289 LOGE("Failed to allocate mgf1 name memory");
290 return HCF_ERR_MALLOC;
291 }
292 (void)memcpy_s(mgf1Str, mgf1Len, HCF_OPENSSL_MGF1, mgf1Len);
293 *returnString = mgf1Str;
294 return HCF_SUCCESS;
295 }
296
GetSm2SpecStringSm3(char ** returnString)297 HcfResult GetSm2SpecStringSm3(char **returnString)
298 {
299 if (returnString == NULL) {
300 LOGE("return string is null");
301 return HCF_INVALID_PARAMS;
302 }
303 size_t sm2Len = HcfStrlen(HCF_OPENSSL_DIGEST_SM3_STR);
304 if (sm2Len == 0) {
305 LOGE("sm2Len is empty!");
306 return HCF_ERR_MALLOC;
307 }
308 char *sm2Str = (char *)HcfMalloc(sm2Len + 1, 0);
309 if (sm2Str == NULL) {
310 LOGE("Failed to allocate sm2 name memory");
311 return HCF_ERR_MALLOC;
312 }
313 if (memcpy_s(sm2Str, sm2Len, HCF_OPENSSL_DIGEST_SM3_STR, sm2Len) != EOK) {
314 LOGE("memcpy sm2Str failed.");
315 HcfFree(sm2Str);
316 return HCF_ERR_MALLOC;
317 }
318 *returnString = sm2Str;
319 return HCF_SUCCESS;
320 }
321
HcfPrintOpensslError(void)322 void HcfPrintOpensslError(void)
323 {
324 char szErr[LOG_PRINT_MAX_LEN] = {0};
325 unsigned long errCode;
326
327 errCode = ERR_get_error();
328 ERR_error_string_n(errCode, szErr, LOG_PRINT_MAX_LEN);
329
330 LOGD("[error] [Openssl]: engine fail, error code = %lu, error string = %s", errCode, szErr);
331 }
332
GetOpensslPadding(int32_t padding,int32_t * opensslPadding)333 HcfResult GetOpensslPadding(int32_t padding, int32_t *opensslPadding)
334 {
335 if (opensslPadding == NULL) {
336 LOGE("return openssl padding pointer is null");
337 return HCF_INVALID_PARAMS;
338 }
339 switch (padding) {
340 case HCF_ALG_NOPADDING:
341 *opensslPadding = RSA_NO_PADDING;
342 return HCF_SUCCESS;
343
344 case HCF_OPENSSL_RSA_PKCS1_PADDING:
345 *opensslPadding = RSA_PKCS1_PADDING;
346 return HCF_SUCCESS;
347
348 case HCF_OPENSSL_RSA_PKCS1_OAEP_PADDING:
349 *opensslPadding = RSA_PKCS1_OAEP_PADDING;
350 return HCF_SUCCESS;
351
352 case HCF_OPENSSL_RSA_PSS_PADDING:
353 *opensslPadding = RSA_PKCS1_PSS_PADDING;
354 return HCF_SUCCESS;
355
356 default:
357 LOGD("[error] Invalid framwork padding = %d", padding);
358 return HCF_INVALID_PARAMS;
359 }
360 }
361
GetRealPrimes(int32_t primesFlag)362 int32_t GetRealPrimes(int32_t primesFlag)
363 {
364 switch (primesFlag) {
365 case HCF_OPENSSL_PRIMES_2:
366 return PRIMES_2;
367 case HCF_OPENSSL_PRIMES_3:
368 return PRIMES_3;
369 case HCF_OPENSSL_PRIMES_4:
370 return PRIMES_4;
371 case HCF_OPENSSL_PRIMES_5:
372 return PRIMES_5;
373 default:
374 LOGD("set default primes 2");
375 return PRIMES_2;
376 }
377 }
378
IsBigEndian(void)379 bool IsBigEndian(void)
380 {
381 uint32_t *pointer = (uint32_t *)&ASCII_CODE_ZERO;
382 char firstChar = *((char *)pointer);
383 if (firstChar == '0') {
384 return false;
385 } else {
386 return true;
387 }
388 }
389
BigIntegerToBigNum(const HcfBigInteger * src,BIGNUM ** dest)390 HcfResult BigIntegerToBigNum(const HcfBigInteger *src, BIGNUM **dest)
391 {
392 if (src == NULL || dest == NULL) {
393 LOGE("Invalid input parameter.");
394 return HCF_INVALID_PARAMS;
395 }
396
397 if (IsBigEndian()) {
398 *dest = Openssl_BN_bin2bn((src->data), (src->len), NULL);
399 } else {
400 *dest = Openssl_BN_lebin2bn((src->data), (src->len), NULL);
401 }
402
403 if (*dest == NULL) {
404 LOGD("[error] translate BigInteger to BIGNUM failed.");
405 HcfPrintOpensslError();
406 return HCF_ERR_CRYPTO_OPERATION;
407 }
408 return HCF_SUCCESS;
409 }
410
BigNumToBigInteger(const BIGNUM * src,HcfBigInteger * dest)411 HcfResult BigNumToBigInteger(const BIGNUM *src, HcfBigInteger *dest)
412 {
413 if (src == NULL || dest == NULL) {
414 LOGE("Invalid input parameter.");
415 return HCF_INVALID_PARAMS;
416 }
417
418 int len = Openssl_BN_num_bytes(src);
419 if (len <= 0) {
420 LOGD("[error] Invalid input parameter.");
421 HcfPrintOpensslError();
422 return HCF_ERR_CRYPTO_OPERATION;
423 }
424 dest->data = (unsigned char *)HcfMalloc(len, 0);
425 if (dest->data == NULL) {
426 LOGE("Alloc dest->data memeory failed.");
427 return HCF_ERR_MALLOC;
428 }
429 dest->len = len;
430
431 int resLen = -1;
432 if (IsBigEndian()) {
433 resLen = Openssl_BN_bn2binpad(src, dest->data, dest->len);
434 } else {
435 resLen = Openssl_BN_bn2lebinpad(src, dest->data, dest->len);
436 }
437
438 if (resLen != len) {
439 LOGD("[error] translate BIGNUM to BigInteger failed.");
440 HcfPrintOpensslError();
441 HcfFree(dest->data);
442 dest->data = NULL;
443 dest->len = 0;
444 return HCF_ERR_CRYPTO_OPERATION;
445 }
446 return HCF_SUCCESS;
447 }
448
KeyDerive(EVP_PKEY * priKey,EVP_PKEY * pubKey,HcfBlob * returnSecret)449 HcfResult KeyDerive(EVP_PKEY *priKey, EVP_PKEY *pubKey, HcfBlob *returnSecret)
450 {
451 EVP_PKEY_CTX *ctx = Openssl_EVP_PKEY_CTX_new(priKey, NULL);
452 if (ctx == NULL) {
453 LOGD("[error] EVP_PKEY_CTX_new failed!");
454 HcfPrintOpensslError();
455 return HCF_ERR_CRYPTO_OPERATION;
456 }
457 HcfResult ret = HCF_ERR_CRYPTO_OPERATION;
458 do {
459 if (Openssl_EVP_PKEY_derive_init(ctx) != HCF_OPENSSL_SUCCESS) {
460 LOGD("[error] Evp key derive init failed!");
461 HcfPrintOpensslError();
462 break;
463 }
464 if (Openssl_EVP_PKEY_derive_set_peer(ctx, pubKey) != HCF_OPENSSL_SUCCESS) {
465 LOGD("[error] Evp key derive set peer failed!");
466 HcfPrintOpensslError();
467 break;
468 }
469 size_t maxLen;
470 if (Openssl_EVP_PKEY_derive(ctx, NULL, &maxLen) != HCF_OPENSSL_SUCCESS) {
471 LOGD("[error] Evp key derive failed!");
472 HcfPrintOpensslError();
473 break;
474 }
475 uint8_t *secretData = (uint8_t *)HcfMalloc(maxLen, 0);
476 if (secretData == NULL) {
477 LOGE("Failed to allocate secretData memory!");
478 ret = HCF_ERR_MALLOC;
479 break;
480 }
481 size_t actualLen = maxLen;
482 if (Openssl_EVP_PKEY_derive(ctx, secretData, &actualLen) != HCF_OPENSSL_SUCCESS) {
483 LOGD("[error] Evp key derive failed!");
484 HcfPrintOpensslError();
485 HcfFree(secretData);
486 break;
487 }
488 if (actualLen > maxLen) {
489 LOGD("[error] signature data too long.");
490 HcfFree(secretData);
491 break;
492 }
493 returnSecret->data = secretData;
494 returnSecret->len = actualLen;
495 ret = HCF_SUCCESS;
496 } while (0);
497 Openssl_EVP_PKEY_CTX_free(ctx);
498 return ret;
499 }
500