1 /*
2 * Copyright (C) 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 #include "dh_openssl_common.h"
16 #include <string.h>
17
18 #include "securec.h"
19
20 #include "detailed_dh_key_params.h"
21 #include "log.h"
22 #include "memory.h"
23 #include "openssl_adapter.h"
24 #include "openssl_class.h"
25 #include "openssl_common.h"
26
27 enum HcfDhNamedGroupId {
28 HCF_DH_MODP_SIZE_1536 = 0,
29 HCF_DH_MODP_SIZE_2048,
30 HCF_DH_MODP_SIZE_3072,
31 HCF_DH_MODP_SIZE_4096,
32 HCF_DH_MODP_SIZE_6144,
33 HCF_DH_MODP_SIZE_8192,
34 HCF_DH_FFDHE_SIZE_2048,
35 HCF_DH_FFDHE_SIZE_3072,
36 HCF_DH_FFDHE_SIZE_4096,
37 HCF_DH_FFDHE_SIZE_6144,
38 HCF_DH_FFDHE_SIZE_8192
39 };
40
41 enum HcfDhPLenSize {
42 HCF_DH_PLEN_2048 = 2048,
43 HCF_DH_PLEN_3072 = 3072,
44 HCF_DH_PLEN_4096 = 4096,
45 HCF_DH_PLEN_6144 = 6144,
46 HCF_DH_PLEN_8192 = 8192
47 };
48
49 typedef struct {
50 enum HcfDhNamedGroupId dhId;
51 char *nidName;
52 } NidNameByType;
53
54 static const NidNameByType NID_NAME_BY_TYPE_MAP[] = {
55 { HCF_DH_MODP_SIZE_1536, "modp_1536" },
56 { HCF_DH_MODP_SIZE_2048, "modp_2048" },
57 { HCF_DH_MODP_SIZE_3072, "modp_3072" },
58 { HCF_DH_MODP_SIZE_4096, "modp_4096" },
59 { HCF_DH_MODP_SIZE_6144, "modp_6144" },
60 { HCF_DH_MODP_SIZE_8192, "modp_8192" },
61 { HCF_DH_FFDHE_SIZE_2048, "ffdhe2048" },
62 { HCF_DH_FFDHE_SIZE_3072, "ffdhe3072" },
63 { HCF_DH_FFDHE_SIZE_4096, "ffdhe4096" },
64 { HCF_DH_FFDHE_SIZE_6144, "ffdhe6144" },
65 { HCF_DH_FFDHE_SIZE_8192, "ffdhe8192" }
66 };
67
68 typedef struct {
69 enum HcfDhPLenSize pLen;
70 char *nidName;
71 } NidNameByPLen;
72
73 static const NidNameByPLen NID_NAME_PLEN_MAP[] = {
74 { HCF_DH_PLEN_2048, "ffdhe2048" },
75 { HCF_DH_PLEN_3072, "ffdhe3072" },
76 { HCF_DH_PLEN_4096, "ffdhe4096" },
77 { HCF_DH_PLEN_6144, "ffdhe6144" },
78 { HCF_DH_PLEN_8192, "ffdhe8192" }
79 };
80
NewEvpPkeyByDh(DH * dh,bool withDuplicate)81 EVP_PKEY *NewEvpPkeyByDh(DH *dh, bool withDuplicate)
82 {
83 if (dh == NULL) {
84 LOGE("DH is NULL");
85 return NULL;
86 }
87 EVP_PKEY *pKey = OpensslEvpPkeyNew();
88 if (pKey == NULL) {
89 LOGD("[error] EVP_PKEY_new fail");
90 HcfPrintOpensslError();
91 return NULL;
92 }
93 if (withDuplicate) {
94 if (OpensslEvpPkeySet1Dh(pKey, dh) != HCF_OPENSSL_SUCCESS) {
95 LOGD("[error] EVP_PKEY_set1_DH fail");
96 HcfPrintOpensslError();
97 OpensslEvpPkeyFree(pKey);
98 return NULL;
99 }
100 } else {
101 if (OpensslEvpPkeyAssignDh(pKey, dh) != HCF_OPENSSL_SUCCESS) {
102 LOGD("[error] EVP_PKEY_assign_DH fail");
103 HcfPrintOpensslError();
104 OpensslEvpPkeyFree(pKey);
105 return NULL;
106 }
107 }
108 return pKey;
109 }
110
GetNidNameByDhId(int32_t pLen)111 char *GetNidNameByDhId(int32_t pLen)
112 {
113 if (pLen < 0) {
114 LOGE("Invalid pLen");
115 return NULL;
116 }
117 for (uint32_t i = 0; i < sizeof(NID_NAME_BY_TYPE_MAP) / sizeof(NID_NAME_BY_TYPE_MAP[0]); i++) {
118 if (NID_NAME_BY_TYPE_MAP[i].dhId == (uint32_t)pLen) {
119 return NID_NAME_BY_TYPE_MAP[i].nidName;
120 }
121 }
122 LOGE("Invalid prime len:%d", pLen);
123 return NULL;
124 }
125
GetNidNameByDhPLen(int32_t pLen)126 char *GetNidNameByDhPLen(int32_t pLen)
127 {
128 if (pLen < 0) {
129 LOGE("Invalid pLen");
130 return NULL;
131 }
132 for (uint32_t i = 0; i < sizeof(NID_NAME_PLEN_MAP) / sizeof(NID_NAME_PLEN_MAP[0]); i++) {
133 if (NID_NAME_PLEN_MAP[i].pLen == (uint32_t)pLen) {
134 return NID_NAME_PLEN_MAP[i].nidName;
135 }
136 }
137 LOGE("Invalid prime len:%d", pLen);
138 return NULL;
139 }
140