diff options
author | jsing <> | 2022-01-05 17:10:03 +0000 |
---|---|---|
committer | jsing <> | 2022-01-05 17:10:03 +0000 |
commit | a9f24628df539c8088b9794446120c0373037961 (patch) | |
tree | bf1d8f80a603da1e77e6fec1a2697b878680932b /src/lib/libssl/tls13_key_share.c | |
parent | c07b503037c3e655a5473421e41fdca747aaad80 (diff) | |
download | openbsd-a9f24628df539c8088b9794446120c0373037961.tar.gz openbsd-a9f24628df539c8088b9794446120c0373037961.tar.bz2 openbsd-a9f24628df539c8088b9794446120c0373037961.zip |
Rename tls13_key_share to tls_key_share.
In preparation to use the key share code in both the TLSv1.3 and legacy
stacks, rename tls13_key_share to tls_key_share, moving it into the shared
handshake struct. Further changes will then allow the legacy stack to make
use of the same code for ephemeral key exchange.
ok inoguchi@ tb@
Diffstat (limited to 'src/lib/libssl/tls13_key_share.c')
-rw-r--r-- | src/lib/libssl/tls13_key_share.c | 306 |
1 files changed, 0 insertions, 306 deletions
diff --git a/src/lib/libssl/tls13_key_share.c b/src/lib/libssl/tls13_key_share.c deleted file mode 100644 index 70f1b673f6..0000000000 --- a/src/lib/libssl/tls13_key_share.c +++ /dev/null | |||
@@ -1,306 +0,0 @@ | |||
1 | /* $OpenBSD: tls13_key_share.c,v 1.7 2022/01/04 11:01:58 jsing Exp $ */ | ||
2 | /* | ||
3 | * Copyright (c) 2020 Joel Sing <jsing@openbsd.org> | ||
4 | * | ||
5 | * Permission to use, copy, modify, and distribute this software for any | ||
6 | * purpose with or without fee is hereby granted, provided that the above | ||
7 | * copyright notice and this permission notice appear in all copies. | ||
8 | * | ||
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
16 | */ | ||
17 | |||
18 | #include <stdlib.h> | ||
19 | |||
20 | #include <openssl/curve25519.h> | ||
21 | |||
22 | #include "bytestring.h" | ||
23 | #include "ssl_locl.h" | ||
24 | #include "tls13_internal.h" | ||
25 | |||
26 | struct tls13_key_share { | ||
27 | int nid; | ||
28 | uint16_t group_id; | ||
29 | |||
30 | EC_KEY *ecdhe; | ||
31 | EC_KEY *ecdhe_peer; | ||
32 | |||
33 | uint8_t *x25519_public; | ||
34 | uint8_t *x25519_private; | ||
35 | uint8_t *x25519_peer_public; | ||
36 | }; | ||
37 | |||
38 | struct tls13_key_share * | ||
39 | tls13_key_share_new(uint16_t group_id) | ||
40 | { | ||
41 | struct tls13_key_share *ks; | ||
42 | int nid; | ||
43 | |||
44 | if ((nid = tls1_ec_curve_id2nid(group_id)) == 0) | ||
45 | return NULL; | ||
46 | |||
47 | if ((ks = calloc(1, sizeof(struct tls13_key_share))) == NULL) | ||
48 | return NULL; | ||
49 | |||
50 | ks->group_id = group_id; | ||
51 | ks->nid = nid; | ||
52 | |||
53 | return ks; | ||
54 | } | ||
55 | |||
56 | struct tls13_key_share * | ||
57 | tls13_key_share_new_nid(int nid) | ||
58 | { | ||
59 | uint16_t group_id; | ||
60 | |||
61 | if ((group_id = tls1_ec_nid2curve_id(nid)) == 0) | ||
62 | return NULL; | ||
63 | |||
64 | return tls13_key_share_new(group_id); | ||
65 | } | ||
66 | |||
67 | void | ||
68 | tls13_key_share_free(struct tls13_key_share *ks) | ||
69 | { | ||
70 | if (ks == NULL) | ||
71 | return; | ||
72 | |||
73 | EC_KEY_free(ks->ecdhe); | ||
74 | EC_KEY_free(ks->ecdhe_peer); | ||
75 | |||
76 | freezero(ks->x25519_public, X25519_KEY_LENGTH); | ||
77 | freezero(ks->x25519_private, X25519_KEY_LENGTH); | ||
78 | freezero(ks->x25519_peer_public, X25519_KEY_LENGTH); | ||
79 | |||
80 | freezero(ks, sizeof(*ks)); | ||
81 | } | ||
82 | |||
83 | uint16_t | ||
84 | tls13_key_share_group(struct tls13_key_share *ks) | ||
85 | { | ||
86 | return ks->group_id; | ||
87 | } | ||
88 | |||
89 | int | ||
90 | tls13_key_share_peer_pkey(struct tls13_key_share *ks, EVP_PKEY *pkey) | ||
91 | { | ||
92 | if (ks->nid == NID_X25519 && ks->x25519_peer_public != NULL) { | ||
93 | if (!ssl_kex_dummy_ecdhe_x25519(pkey)) | ||
94 | return 0; | ||
95 | } else if (ks->ecdhe_peer != NULL) { | ||
96 | if (!EVP_PKEY_set1_EC_KEY(pkey, ks->ecdhe_peer)) | ||
97 | return 0; | ||
98 | } else { | ||
99 | return 0; | ||
100 | } | ||
101 | |||
102 | return 1; | ||
103 | } | ||
104 | |||
105 | static int | ||
106 | tls13_key_share_generate_ecdhe_ecp(struct tls13_key_share *ks) | ||
107 | { | ||
108 | EC_KEY *ecdhe = NULL; | ||
109 | int ret = 0; | ||
110 | |||
111 | if (ks->ecdhe != NULL) | ||
112 | goto err; | ||
113 | |||
114 | if ((ecdhe = EC_KEY_new()) == NULL) | ||
115 | goto err; | ||
116 | if (!ssl_kex_generate_ecdhe_ecp(ecdhe, ks->nid)) | ||
117 | goto err; | ||
118 | |||
119 | ks->ecdhe = ecdhe; | ||
120 | ecdhe = NULL; | ||
121 | |||
122 | ret = 1; | ||
123 | |||
124 | err: | ||
125 | EC_KEY_free(ecdhe); | ||
126 | |||
127 | return ret; | ||
128 | } | ||
129 | |||
130 | static int | ||
131 | tls13_key_share_generate_x25519(struct tls13_key_share *ks) | ||
132 | { | ||
133 | uint8_t *public = NULL, *private = NULL; | ||
134 | int ret = 0; | ||
135 | |||
136 | if (ks->x25519_public != NULL || ks->x25519_private != NULL) | ||
137 | goto err; | ||
138 | |||
139 | if ((public = calloc(1, X25519_KEY_LENGTH)) == NULL) | ||
140 | goto err; | ||
141 | if ((private = calloc(1, X25519_KEY_LENGTH)) == NULL) | ||
142 | goto err; | ||
143 | |||
144 | X25519_keypair(public, private); | ||
145 | |||
146 | ks->x25519_public = public; | ||
147 | ks->x25519_private = private; | ||
148 | public = NULL; | ||
149 | private = NULL; | ||
150 | |||
151 | ret = 1; | ||
152 | |||
153 | err: | ||
154 | freezero(public, X25519_KEY_LENGTH); | ||
155 | freezero(private, X25519_KEY_LENGTH); | ||
156 | |||
157 | return ret; | ||
158 | } | ||
159 | |||
160 | int | ||
161 | tls13_key_share_generate(struct tls13_key_share *ks) | ||
162 | { | ||
163 | if (ks->nid == NID_X25519) | ||
164 | return tls13_key_share_generate_x25519(ks); | ||
165 | |||
166 | return tls13_key_share_generate_ecdhe_ecp(ks); | ||
167 | } | ||
168 | |||
169 | static int | ||
170 | tls13_key_share_public_ecdhe_ecp(struct tls13_key_share *ks, CBB *cbb) | ||
171 | { | ||
172 | if (ks->ecdhe == NULL) | ||
173 | return 0; | ||
174 | |||
175 | return ssl_kex_public_ecdhe_ecp(ks->ecdhe, cbb); | ||
176 | } | ||
177 | |||
178 | static int | ||
179 | tls13_key_share_public_x25519(struct tls13_key_share *ks, CBB *cbb) | ||
180 | { | ||
181 | if (ks->x25519_public == NULL) | ||
182 | return 0; | ||
183 | |||
184 | return CBB_add_bytes(cbb, ks->x25519_public, X25519_KEY_LENGTH); | ||
185 | } | ||
186 | |||
187 | int | ||
188 | tls13_key_share_public(struct tls13_key_share *ks, CBB *cbb) | ||
189 | { | ||
190 | if (ks->nid == NID_X25519) | ||
191 | return tls13_key_share_public_x25519(ks, cbb); | ||
192 | |||
193 | return tls13_key_share_public_ecdhe_ecp(ks, cbb); | ||
194 | } | ||
195 | |||
196 | static int | ||
197 | tls13_key_share_peer_public_ecdhe_ecp(struct tls13_key_share *ks, CBS *cbs) | ||
198 | { | ||
199 | EC_KEY *ecdhe = NULL; | ||
200 | int ret = 0; | ||
201 | |||
202 | if (ks->ecdhe_peer != NULL) | ||
203 | goto err; | ||
204 | |||
205 | if ((ecdhe = EC_KEY_new()) == NULL) | ||
206 | goto err; | ||
207 | if (!ssl_kex_peer_public_ecdhe_ecp(ecdhe, ks->nid, cbs)) | ||
208 | goto err; | ||
209 | |||
210 | ks->ecdhe_peer = ecdhe; | ||
211 | ecdhe = NULL; | ||
212 | |||
213 | ret = 1; | ||
214 | |||
215 | err: | ||
216 | EC_KEY_free(ecdhe); | ||
217 | |||
218 | return ret; | ||
219 | } | ||
220 | |||
221 | static int | ||
222 | tls13_key_share_peer_public_x25519(struct tls13_key_share *ks, CBS *cbs) | ||
223 | { | ||
224 | size_t out_len; | ||
225 | |||
226 | if (ks->x25519_peer_public != NULL) | ||
227 | return 0; | ||
228 | |||
229 | if (CBS_len(cbs) != X25519_KEY_LENGTH) | ||
230 | return 0; | ||
231 | |||
232 | return CBS_stow(cbs, &ks->x25519_peer_public, &out_len); | ||
233 | } | ||
234 | |||
235 | int | ||
236 | tls13_key_share_peer_public(struct tls13_key_share *ks, uint16_t group, | ||
237 | CBS *cbs) | ||
238 | { | ||
239 | if (ks->group_id != group) | ||
240 | return 0; | ||
241 | |||
242 | if (ks->nid == NID_X25519) { | ||
243 | if (!tls13_key_share_peer_public_x25519(ks, cbs)) | ||
244 | return 0; | ||
245 | } else { | ||
246 | if (!tls13_key_share_peer_public_ecdhe_ecp(ks, cbs)) | ||
247 | return 0; | ||
248 | } | ||
249 | |||
250 | return 1; | ||
251 | } | ||
252 | |||
253 | static int | ||
254 | tls13_key_share_derive_ecdhe_ecp(struct tls13_key_share *ks, | ||
255 | uint8_t **shared_key, size_t *shared_key_len) | ||
256 | { | ||
257 | if (ks->ecdhe == NULL || ks->ecdhe_peer == NULL) | ||
258 | return 0; | ||
259 | |||
260 | return ssl_kex_derive_ecdhe_ecp(ks->ecdhe, ks->ecdhe_peer, | ||
261 | shared_key, shared_key_len); | ||
262 | } | ||
263 | |||
264 | static int | ||
265 | tls13_key_share_derive_x25519(struct tls13_key_share *ks, | ||
266 | uint8_t **shared_key, size_t *shared_key_len) | ||
267 | { | ||
268 | uint8_t *sk = NULL; | ||
269 | int ret = 0; | ||
270 | |||
271 | if (ks->x25519_private == NULL || ks->x25519_peer_public == NULL) | ||
272 | goto err; | ||
273 | |||
274 | if ((sk = calloc(1, X25519_KEY_LENGTH)) == NULL) | ||
275 | goto err; | ||
276 | if (!X25519(sk, ks->x25519_private, ks->x25519_peer_public)) | ||
277 | goto err; | ||
278 | |||
279 | *shared_key = sk; | ||
280 | *shared_key_len = X25519_KEY_LENGTH; | ||
281 | sk = NULL; | ||
282 | |||
283 | ret = 1; | ||
284 | |||
285 | err: | ||
286 | freezero(sk, X25519_KEY_LENGTH); | ||
287 | |||
288 | return ret; | ||
289 | } | ||
290 | |||
291 | int | ||
292 | tls13_key_share_derive(struct tls13_key_share *ks, uint8_t **shared_key, | ||
293 | size_t *shared_key_len) | ||
294 | { | ||
295 | if (*shared_key != NULL) | ||
296 | return 0; | ||
297 | |||
298 | *shared_key_len = 0; | ||
299 | |||
300 | if (ks->nid == NID_X25519) | ||
301 | return tls13_key_share_derive_x25519(ks, shared_key, | ||
302 | shared_key_len); | ||
303 | |||
304 | return tls13_key_share_derive_ecdhe_ecp(ks, shared_key, | ||
305 | shared_key_len); | ||
306 | } | ||