1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 #include <stddef.h>
17 #include "hitls_build.h"
18 #include "config_type.h"
19 #include "hitls_crypt_type.h"
20 #include "tls_config.h"
21 #include "hitls_error.h"
22 #include "crypt_algid.h"
23 #include "config.h"
24 #ifdef HITLS_TLS_FEATURE_PROVIDER
25 #include "securec.h"
26 #include "crypt_eal_provider.h"
27 #include "crypt_params_key.h"
28 #include "crypt_eal_implprovider.h"
29 #include "crypt_eal_pkey.h"
30 #endif
31
32 static const uint16_t DEFAULT_GROUP_ID[] = {
33 HITLS_HYBRID_X25519_MLKEM768,
34 HITLS_EC_GROUP_CURVE25519,
35 HITLS_EC_GROUP_SECP256R1,
36 HITLS_EC_GROUP_SECP384R1,
37 HITLS_EC_GROUP_SECP521R1,
38 HITLS_EC_GROUP_SM2,
39 HITLS_FF_DHE_2048,
40 HITLS_FF_DHE_3072,
41 HITLS_FF_DHE_4096,
42 HITLS_FF_DHE_6144,
43 HITLS_FF_DHE_8192,
44 };
45
46 #ifndef HITLS_TLS_FEATURE_PROVIDER
47 static const TLS_GroupInfo GROUP_INFO[] = {
48 {
49 "x25519",
50 CRYPT_PKEY_PARAID_MAX,
51 CRYPT_PKEY_X25519,
52 128, // secBits
53 HITLS_EC_GROUP_CURVE25519, // groupId
54 32, 32, 0, // pubkeyLen=32, sharedkeyLen=32 (256 bits)
55 TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
56 false,
57 },
58 #ifdef HITLS_TLS_FEATURE_KEM
59 {
60 "X25519MLKEM768",
61 CRYPT_HYBRID_X25519_MLKEM768,
62 CRYPT_PKEY_HYBRID_KEM,
63 192, // secBits
64 HITLS_HYBRID_X25519_MLKEM768, // groupId
65 1184 + 32, 32 + 32, 1088 + 32, // pubkeyLen=1216, sharedkeyLen=64, ciphertextLen=1120
66 TLS13_VERSION_BIT, // versionBits
67 true,
68 },
69 {
70 "SecP256r1MLKEM768",
71 CRYPT_HYBRID_ECDH_NISTP256_MLKEM768,
72 CRYPT_PKEY_HYBRID_KEM,
73 192, // secBits
74 HITLS_HYBRID_ECDH_NISTP256_MLKEM768, // groupId
75 1184 + 65, 32 + 32, 1088 + 65, // pubkeyLen=1249, sharedkeyLen=64, ciphertextLen=1153
76 TLS13_VERSION_BIT, // versionBits
77 true,
78 },
79 {
80 "SecP384r1MLKEM1024",
81 CRYPT_HYBRID_ECDH_NISTP384_MLKEM1024,
82 CRYPT_PKEY_HYBRID_KEM,
83 256, // secBits
84 HITLS_HYBRID_ECDH_NISTP384_MLKEM1024, // groupId
85 1568 + 97, 32 + 48, 1568 + 97, // pubkeyLen=1665, sharedkeyLen=80, ciphertextLen=1665
86 TLS13_VERSION_BIT, // versionBits
87 true,
88 },
89 #endif /* HITLS_TLS_FEATURE_KEM */
90 {
91 "secp256r1",
92 CRYPT_ECC_NISTP256, // CRYPT_ECC_NISTP256
93 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
94 128, // secBits
95 HITLS_EC_GROUP_SECP256R1, // groupId
96 65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
97 TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
98 false,
99 },
100 {
101 "secp384r1",
102 CRYPT_ECC_NISTP384, // CRYPT_ECC_NISTP384
103 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
104 192, // secBits
105 HITLS_EC_GROUP_SECP384R1, // groupId
106 97, 48, 0, // pubkeyLen=97, sharedkeyLen=48 (384 bits)
107 TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
108 false,
109 },
110 {
111 "secp521r1",
112 CRYPT_ECC_NISTP521, // CRYPT_ECC_NISTP521
113 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
114 256, // secBits
115 HITLS_EC_GROUP_SECP521R1, // groupId
116 133, 66, 0, // pubkeyLen=133, sharedkeyLen=66 (521 bits)
117 TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
118 false,
119 },
120 {
121 "brainpoolP256r1",
122 CRYPT_ECC_BRAINPOOLP256R1, // CRYPT_ECC_BRAINPOOLP256R1
123 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
124 128, // secBits
125 HITLS_EC_GROUP_BRAINPOOLP256R1, // groupId
126 65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
127 TLS10_VERSION_BIT | TLS11_VERSION_BIT| TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
128 false,
129 },
130 {
131 "brainpoolP384r1",
132 CRYPT_ECC_BRAINPOOLP384R1, // CRYPT_ECC_BRAINPOOLP384R1
133 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
134 192, // secBits
135 HITLS_EC_GROUP_BRAINPOOLP384R1, // groupId
136 97, 48, 0, // pubkeyLen=97, sharedkeyLen=48 (384 bits)
137 TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
138 false,
139 },
140 {
141 "brainpoolP512r1",
142 CRYPT_ECC_BRAINPOOLP512R1, // CRYPT_ECC_BRAINPOOLP512R1
143 CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
144 256, // secBits
145 HITLS_EC_GROUP_BRAINPOOLP512R1, // groupId
146 129, 64, 0, // pubkeyLen=129, sharedkeyLen=64 (512 bits)
147 TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
148 false,
149 },
150 {
151 "sm2",
152 CRYPT_PKEY_PARAID_MAX, // CRYPT_PKEY_PARAID_MAX
153 CRYPT_PKEY_SM2, // CRYPT_PKEY_SM2
154 128, // secBits
155 HITLS_EC_GROUP_SM2, // groupId
156 65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
157 TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT, // versionBits
158 false,
159 },
160 {
161 "ffdhe8192",
162 CRYPT_DH_RFC7919_8192, // CRYPT_DH_8192
163 CRYPT_PKEY_DH, // CRYPT_PKEY_DH
164 192, // secBits
165 HITLS_FF_DHE_8192, // groupId
166 1024, 1024, 0, // pubkeyLen=1024, sharedkeyLen=1024 (8192 bits)
167 TLS13_VERSION_BIT, // versionBits
168 false,
169 },
170 {
171 "ffdhe6144",
172 CRYPT_DH_RFC7919_6144, // CRYPT_DH_6144
173 CRYPT_PKEY_DH, // CRYPT_PKEY_DH
174 128, // secBits
175 HITLS_FF_DHE_6144, // groupId
176 768, 768, 0, // pubkeyLen=768, sharedkeyLen=768 (6144 bits)
177 TLS13_VERSION_BIT, // versionBits
178 false,
179 },
180 {
181 "ffdhe4096",
182 CRYPT_DH_RFC7919_4096, // CRYPT_DH_4096
183 CRYPT_PKEY_DH, // CRYPT_PKEY_DH
184 128, // secBits
185 HITLS_FF_DHE_4096, // groupId
186 512, 512, 0, // pubkeyLen=512, sharedkeyLen=512 (4096 bits)
187 TLS13_VERSION_BIT, // versionBits
188 false,
189 },
190 {
191 "ffdhe3072",
192 CRYPT_DH_RFC7919_3072, // Fixed constant name
193 CRYPT_PKEY_DH,
194 128,
195 HITLS_FF_DHE_3072,
196 384, 384, 0, // pubkeyLen=384, sharedkeyLen=384 (3072 bits)
197 TLS13_VERSION_BIT,
198 false,
199 },
200 {
201 "ffdhe2048",
202 CRYPT_DH_RFC7919_2048, // CRYPT_DH_2048
203 CRYPT_PKEY_DH, // CRYPT_PKEY_DH
204 112, // secBits
205 HITLS_FF_DHE_2048, // groupId
206 256, 256, 0, // pubkeyLen=256, sharedkeyLen=256 (2048 bits)
207 TLS13_VERSION_BIT, // versionBits
208 false,
209 }
210 };
211
ConfigLoadGroupInfo(HITLS_Config * config)212 int32_t ConfigLoadGroupInfo(HITLS_Config *config)
213 {
214 if (config == NULL) {
215 return HITLS_INVALID_INPUT;
216 }
217 return HITLS_CFG_SetGroups(config, DEFAULT_GROUP_ID, sizeof(DEFAULT_GROUP_ID) / sizeof(DEFAULT_GROUP_ID[0]));
218 }
219
ConfigGetGroupInfo(const HITLS_Config * config,uint16_t groupId)220 const TLS_GroupInfo *ConfigGetGroupInfo(const HITLS_Config *config, uint16_t groupId)
221 {
222 (void)config;
223 for (uint32_t i = 0; i < sizeof(GROUP_INFO) / sizeof(TLS_GroupInfo); i++) {
224 if (GROUP_INFO[i].groupId == groupId) {
225 return &GROUP_INFO[i];
226 }
227 }
228 return NULL;
229 }
230
ConfigGetGroupInfoList(const HITLS_Config * config,uint32_t * size)231 const TLS_GroupInfo *ConfigGetGroupInfoList(const HITLS_Config *config, uint32_t *size)
232 {
233 (void)config;
234 *size = sizeof(GROUP_INFO) / sizeof(GROUP_INFO[0]);
235 return &GROUP_INFO[0];
236 }
237 #else
238
ProviderAddGroupInfo(const BSL_Param * params,void * args)239 static int32_t ProviderAddGroupInfo(const BSL_Param *params, void *args)
240 {
241 if (params == NULL || args == NULL) {
242 return HITLS_INVALID_INPUT;
243 }
244 TLS_CapabilityData *data = (TLS_CapabilityData *)args;
245 TLS_Config *config = data->config;
246 TLS_GroupInfo *group = NULL;
247 CRYPT_EAL_PkeyCtx *pkey = NULL;
248 BSL_Param *param = NULL;
249 int32_t ret = HITLS_CONFIG_ERR_LOAD_GROUP_INFO;
250 if (config->groupInfolen == config->groupInfoSize) {
251 void *ptr = BSL_SAL_Realloc(config->groupInfo,
252 (config->groupInfoSize + TLS_CAPABILITY_LIST_MALLOC_SIZE) * sizeof(TLS_GroupInfo),
253 config->groupInfoSize * sizeof(TLS_GroupInfo));
254 if (ptr == NULL) {
255 return HITLS_MEMALLOC_FAIL;
256 }
257 config->groupInfo = ptr;
258 (void)memset_s(config->groupInfo + config->groupInfoSize,
259 TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_GroupInfo),
260 0,
261 TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_GroupInfo));
262 config->groupInfoSize += TLS_CAPABILITY_LIST_MALLOC_SIZE;
263 }
264
265 group = config->groupInfo + config->groupInfolen;
266 PROCESS_STRING_PARAM(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_NAME, name);
267 PROCESS_PARAM_UINT16(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_ID, groupId);
268 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_PARA_ID, paraId);
269 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_ALG_ID, algId);
270 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_SEC_BITS, secBits);
271 PROCESS_PARAM_UINT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_VERSION_BITS, versionBits);
272 PROCESS_PARAM_BOOL(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IS_KEM, isKem);
273 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_PUBKEY_LEN, pubkeyLen);
274 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_SHAREDKEY_LEN, sharedkeyLen);
275 PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_CIPHERTEXT_LEN, ciphertextLen);
276
277 ret = HITLS_SUCCESS;
278 pkey = CRYPT_EAL_ProviderPkeyNewCtx(LIBCTX_FROM_CONFIG(config), group->algId, group->isKem ? CRYPT_EAL_PKEY_KEM_OPERATE : CRYPT_EAL_PKEY_EXCH_OPERATE,
279 ATTRIBUTE_FROM_CONFIG(config));
280 if (pkey != NULL) {
281 config->groupInfolen++;
282 CRYPT_EAL_PkeyFreeCtx(pkey);
283 group = NULL;
284 }
285
286 ERR:
287 if (group != NULL) {
288 BSL_SAL_Free(group->name);
289 (void)memset_s(group, sizeof(TLS_GroupInfo), 0, sizeof(TLS_GroupInfo));
290 }
291 return ret;
292 }
293
ProviderLoadGroupInfo(CRYPT_EAL_ProvMgrCtx * ctx,void * args)294 static int32_t ProviderLoadGroupInfo(CRYPT_EAL_ProvMgrCtx *ctx, void *args)
295 {
296 if (ctx == NULL || args == NULL) {
297 return HITLS_INVALID_INPUT;
298 }
299 TLS_CapabilityData data = {
300 .config = (TLS_Config *)args,
301 .provMgrCtx = ctx,
302 };
303 return CRYPT_EAL_ProviderGetCaps(ctx, CRYPT_EAL_GET_GROUP_CAP, ProviderAddGroupInfo, &data);
304 }
305
ConfigLoadGroupInfo(HITLS_Config * config)306 int32_t ConfigLoadGroupInfo(HITLS_Config *config)
307 {
308 HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CONFIG(config);
309 int32_t ret = CRYPT_EAL_ProviderProcessAll(libCtx, ProviderLoadGroupInfo, config);
310 if (ret != HITLS_SUCCESS) {
311 return ret;
312 }
313 return HITLS_CFG_SetGroups(config, DEFAULT_GROUP_ID, sizeof(DEFAULT_GROUP_ID) / sizeof(DEFAULT_GROUP_ID[0]));
314 }
315
ConfigGetGroupInfo(const HITLS_Config * config,uint16_t groupId)316 const TLS_GroupInfo *ConfigGetGroupInfo(const HITLS_Config *config, uint16_t groupId)
317 {
318 for (uint32_t i = 0; i < config->groupInfolen; i++) {
319 if (config->groupInfo[i].groupId == groupId) {
320 return &config->groupInfo[i];
321 }
322 }
323 return NULL;
324 }
325
ConfigGetGroupInfoList(const HITLS_Config * config,uint32_t * size)326 const TLS_GroupInfo *ConfigGetGroupInfoList(const HITLS_Config *config, uint32_t *size)
327 {
328 *size = config->groupInfolen;
329 return config->groupInfo;
330 }
331 #endif
332