xref: /openbmc/linux/net/handshake/tlshd.c (revision 22b6e7f3) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Establish a TLS session for a kernel socket consumer
4  * using the tlshd user space handler.
5  *
6  * Author: Chuck Lever <chuck.lever@oracle.com>
7  *
8  * Copyright (c) 2021-2023, Oracle and/or its affiliates.
9  */
10 
11 #include <linux/types.h>
12 #include <linux/socket.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/key.h>
17 
18 #include <net/sock.h>
19 #include <net/handshake.h>
20 #include <net/genetlink.h>
21 #include <net/tls_prot.h>
22 
23 #include <uapi/linux/keyctl.h>
24 #include <uapi/linux/handshake.h>
25 #include "handshake.h"
26 
27 struct tls_handshake_req {
28 	void			(*th_consumer_done)(void *data, int status,
29 						    key_serial_t peerid);
30 	void			*th_consumer_data;
31 
32 	int			th_type;
33 	unsigned int		th_timeout_ms;
34 	int			th_auth_mode;
35 	const char		*th_peername;
36 	key_serial_t		th_keyring;
37 	key_serial_t		th_certificate;
38 	key_serial_t		th_privkey;
39 
40 	unsigned int		th_num_peerids;
41 	key_serial_t		th_peerid[5];
42 };
43 
44 static struct tls_handshake_req *
45 tls_handshake_req_init(struct handshake_req *req,
46 		       const struct tls_handshake_args *args)
47 {
48 	struct tls_handshake_req *treq = handshake_req_private(req);
49 
50 	treq->th_timeout_ms = args->ta_timeout_ms;
51 	treq->th_consumer_done = args->ta_done;
52 	treq->th_consumer_data = args->ta_data;
53 	treq->th_peername = args->ta_peername;
54 	treq->th_keyring = args->ta_keyring;
55 	treq->th_num_peerids = 0;
56 	treq->th_certificate = TLS_NO_CERT;
57 	treq->th_privkey = TLS_NO_PRIVKEY;
58 	return treq;
59 }
60 
61 static void tls_handshake_remote_peerids(struct tls_handshake_req *treq,
62 					 struct genl_info *info)
63 {
64 	struct nlattr *head = nlmsg_attrdata(info->nlhdr, GENL_HDRLEN);
65 	int rem, len = nlmsg_attrlen(info->nlhdr, GENL_HDRLEN);
66 	struct nlattr *nla;
67 	unsigned int i;
68 
69 	i = 0;
70 	nla_for_each_attr(nla, head, len, rem) {
71 		if (nla_type(nla) == HANDSHAKE_A_DONE_REMOTE_AUTH)
72 			i++;
73 	}
74 	if (!i)
75 		return;
76 	treq->th_num_peerids = min_t(unsigned int, i,
77 				     ARRAY_SIZE(treq->th_peerid));
78 
79 	i = 0;
80 	nla_for_each_attr(nla, head, len, rem) {
81 		if (nla_type(nla) == HANDSHAKE_A_DONE_REMOTE_AUTH)
82 			treq->th_peerid[i++] = nla_get_u32(nla);
83 		if (i >= treq->th_num_peerids)
84 			break;
85 	}
86 }
87 
88 /**
89  * tls_handshake_done - callback to handle a CMD_DONE request
90  * @req: socket on which the handshake was performed
91  * @status: session status code
92  * @info: full results of session establishment
93  *
94  */
95 static void tls_handshake_done(struct handshake_req *req,
96 			       unsigned int status, struct genl_info *info)
97 {
98 	struct tls_handshake_req *treq = handshake_req_private(req);
99 
100 	treq->th_peerid[0] = TLS_NO_PEERID;
101 	if (info)
102 		tls_handshake_remote_peerids(treq, info);
103 
104 	if (!status)
105 		set_bit(HANDSHAKE_F_REQ_SESSION, &req->hr_flags);
106 
107 	treq->th_consumer_done(treq->th_consumer_data, -status,
108 			       treq->th_peerid[0]);
109 }
110 
111 #if IS_ENABLED(CONFIG_KEYS)
112 static int tls_handshake_private_keyring(struct tls_handshake_req *treq)
113 {
114 	key_ref_t process_keyring_ref, keyring_ref;
115 	int ret;
116 
117 	if (treq->th_keyring == TLS_NO_KEYRING)
118 		return 0;
119 
120 	process_keyring_ref = lookup_user_key(KEY_SPEC_PROCESS_KEYRING,
121 					      KEY_LOOKUP_CREATE,
122 					      KEY_NEED_WRITE);
123 	if (IS_ERR(process_keyring_ref)) {
124 		ret = PTR_ERR(process_keyring_ref);
125 		goto out;
126 	}
127 
128 	keyring_ref = lookup_user_key(treq->th_keyring, KEY_LOOKUP_CREATE,
129 				      KEY_NEED_LINK);
130 	if (IS_ERR(keyring_ref)) {
131 		ret = PTR_ERR(keyring_ref);
132 		goto out_put_key;
133 	}
134 
135 	ret = key_link(key_ref_to_ptr(process_keyring_ref),
136 		       key_ref_to_ptr(keyring_ref));
137 
138 	key_ref_put(keyring_ref);
139 out_put_key:
140 	key_ref_put(process_keyring_ref);
141 out:
142 	return ret;
143 }
144 #else
145 static int tls_handshake_private_keyring(struct tls_handshake_req *treq)
146 {
147 	return 0;
148 }
149 #endif
150 
151 static int tls_handshake_put_peer_identity(struct sk_buff *msg,
152 					   struct tls_handshake_req *treq)
153 {
154 	unsigned int i;
155 
156 	for (i = 0; i < treq->th_num_peerids; i++)
157 		if (nla_put_u32(msg, HANDSHAKE_A_ACCEPT_PEER_IDENTITY,
158 				treq->th_peerid[i]) < 0)
159 			return -EMSGSIZE;
160 	return 0;
161 }
162 
163 static int tls_handshake_put_certificate(struct sk_buff *msg,
164 					 struct tls_handshake_req *treq)
165 {
166 	struct nlattr *entry_attr;
167 
168 	if (treq->th_certificate == TLS_NO_CERT &&
169 	    treq->th_privkey == TLS_NO_PRIVKEY)
170 		return 0;
171 
172 	entry_attr = nla_nest_start(msg, HANDSHAKE_A_ACCEPT_CERTIFICATE);
173 	if (!entry_attr)
174 		return -EMSGSIZE;
175 
176 	if (nla_put_u32(msg, HANDSHAKE_A_X509_CERT,
177 			treq->th_certificate) ||
178 	    nla_put_u32(msg, HANDSHAKE_A_X509_PRIVKEY,
179 			treq->th_privkey)) {
180 		nla_nest_cancel(msg, entry_attr);
181 		return -EMSGSIZE;
182 	}
183 
184 	nla_nest_end(msg, entry_attr);
185 	return 0;
186 }
187 
188 /**
189  * tls_handshake_accept - callback to construct a CMD_ACCEPT response
190  * @req: handshake parameters to return
191  * @info: generic netlink message context
192  * @fd: file descriptor to be returned
193  *
194  * Returns zero on success, or a negative errno on failure.
195  */
196 static int tls_handshake_accept(struct handshake_req *req,
197 				struct genl_info *info, int fd)
198 {
199 	struct tls_handshake_req *treq = handshake_req_private(req);
200 	struct nlmsghdr *hdr;
201 	struct sk_buff *msg;
202 	int ret;
203 
204 	ret = tls_handshake_private_keyring(treq);
205 	if (ret < 0)
206 		goto out;
207 
208 	ret = -ENOMEM;
209 	msg = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
210 	if (!msg)
211 		goto out;
212 	hdr = handshake_genl_put(msg, info);
213 	if (!hdr)
214 		goto out_cancel;
215 
216 	ret = -EMSGSIZE;
217 	ret = nla_put_u32(msg, HANDSHAKE_A_ACCEPT_SOCKFD, fd);
218 	if (ret < 0)
219 		goto out_cancel;
220 	ret = nla_put_u32(msg, HANDSHAKE_A_ACCEPT_MESSAGE_TYPE, treq->th_type);
221 	if (ret < 0)
222 		goto out_cancel;
223 	if (treq->th_peername) {
224 		ret = nla_put_string(msg, HANDSHAKE_A_ACCEPT_PEERNAME,
225 				     treq->th_peername);
226 		if (ret < 0)
227 			goto out_cancel;
228 	}
229 	if (treq->th_timeout_ms) {
230 		ret = nla_put_u32(msg, HANDSHAKE_A_ACCEPT_TIMEOUT, treq->th_timeout_ms);
231 		if (ret < 0)
232 			goto out_cancel;
233 	}
234 
235 	ret = nla_put_u32(msg, HANDSHAKE_A_ACCEPT_AUTH_MODE,
236 			  treq->th_auth_mode);
237 	if (ret < 0)
238 		goto out_cancel;
239 	switch (treq->th_auth_mode) {
240 	case HANDSHAKE_AUTH_PSK:
241 		ret = tls_handshake_put_peer_identity(msg, treq);
242 		if (ret < 0)
243 			goto out_cancel;
244 		break;
245 	case HANDSHAKE_AUTH_X509:
246 		ret = tls_handshake_put_certificate(msg, treq);
247 		if (ret < 0)
248 			goto out_cancel;
249 		break;
250 	}
251 
252 	genlmsg_end(msg, hdr);
253 	return genlmsg_reply(msg, info);
254 
255 out_cancel:
256 	genlmsg_cancel(msg, hdr);
257 out:
258 	return ret;
259 }
260 
261 static const struct handshake_proto tls_handshake_proto = {
262 	.hp_handler_class	= HANDSHAKE_HANDLER_CLASS_TLSHD,
263 	.hp_privsize		= sizeof(struct tls_handshake_req),
264 	.hp_flags		= BIT(HANDSHAKE_F_PROTO_NOTIFY),
265 
266 	.hp_accept		= tls_handshake_accept,
267 	.hp_done		= tls_handshake_done,
268 };
269 
270 /**
271  * tls_client_hello_anon - request an anonymous TLS handshake on a socket
272  * @args: socket and handshake parameters for this request
273  * @flags: memory allocation control flags
274  *
275  * Return values:
276  *   %0: Handshake request enqueue; ->done will be called when complete
277  *   %-ESRCH: No user agent is available
278  *   %-ENOMEM: Memory allocation failed
279  */
280 int tls_client_hello_anon(const struct tls_handshake_args *args, gfp_t flags)
281 {
282 	struct tls_handshake_req *treq;
283 	struct handshake_req *req;
284 
285 	req = handshake_req_alloc(&tls_handshake_proto, flags);
286 	if (!req)
287 		return -ENOMEM;
288 	treq = tls_handshake_req_init(req, args);
289 	treq->th_type = HANDSHAKE_MSG_TYPE_CLIENTHELLO;
290 	treq->th_auth_mode = HANDSHAKE_AUTH_UNAUTH;
291 
292 	return handshake_req_submit(args->ta_sock, req, flags);
293 }
294 EXPORT_SYMBOL(tls_client_hello_anon);
295 
296 /**
297  * tls_client_hello_x509 - request an x.509-based TLS handshake on a socket
298  * @args: socket and handshake parameters for this request
299  * @flags: memory allocation control flags
300  *
301  * Return values:
302  *   %0: Handshake request enqueue; ->done will be called when complete
303  *   %-ESRCH: No user agent is available
304  *   %-ENOMEM: Memory allocation failed
305  */
306 int tls_client_hello_x509(const struct tls_handshake_args *args, gfp_t flags)
307 {
308 	struct tls_handshake_req *treq;
309 	struct handshake_req *req;
310 
311 	req = handshake_req_alloc(&tls_handshake_proto, flags);
312 	if (!req)
313 		return -ENOMEM;
314 	treq = tls_handshake_req_init(req, args);
315 	treq->th_type = HANDSHAKE_MSG_TYPE_CLIENTHELLO;
316 	treq->th_auth_mode = HANDSHAKE_AUTH_X509;
317 	treq->th_certificate = args->ta_my_cert;
318 	treq->th_privkey = args->ta_my_privkey;
319 
320 	return handshake_req_submit(args->ta_sock, req, flags);
321 }
322 EXPORT_SYMBOL(tls_client_hello_x509);
323 
324 /**
325  * tls_client_hello_psk - request a PSK-based TLS handshake on a socket
326  * @args: socket and handshake parameters for this request
327  * @flags: memory allocation control flags
328  *
329  * Return values:
330  *   %0: Handshake request enqueue; ->done will be called when complete
331  *   %-EINVAL: Wrong number of local peer IDs
332  *   %-ESRCH: No user agent is available
333  *   %-ENOMEM: Memory allocation failed
334  */
335 int tls_client_hello_psk(const struct tls_handshake_args *args, gfp_t flags)
336 {
337 	struct tls_handshake_req *treq;
338 	struct handshake_req *req;
339 	unsigned int i;
340 
341 	if (!args->ta_num_peerids ||
342 	    args->ta_num_peerids > ARRAY_SIZE(treq->th_peerid))
343 		return -EINVAL;
344 
345 	req = handshake_req_alloc(&tls_handshake_proto, flags);
346 	if (!req)
347 		return -ENOMEM;
348 	treq = tls_handshake_req_init(req, args);
349 	treq->th_type = HANDSHAKE_MSG_TYPE_CLIENTHELLO;
350 	treq->th_auth_mode = HANDSHAKE_AUTH_PSK;
351 	treq->th_num_peerids = args->ta_num_peerids;
352 	for (i = 0; i < args->ta_num_peerids; i++)
353 		treq->th_peerid[i] = args->ta_my_peerids[i];
354 
355 	return handshake_req_submit(args->ta_sock, req, flags);
356 }
357 EXPORT_SYMBOL(tls_client_hello_psk);
358 
359 /**
360  * tls_server_hello_x509 - request a server TLS handshake on a socket
361  * @args: socket and handshake parameters for this request
362  * @flags: memory allocation control flags
363  *
364  * Return values:
365  *   %0: Handshake request enqueue; ->done will be called when complete
366  *   %-ESRCH: No user agent is available
367  *   %-ENOMEM: Memory allocation failed
368  */
369 int tls_server_hello_x509(const struct tls_handshake_args *args, gfp_t flags)
370 {
371 	struct tls_handshake_req *treq;
372 	struct handshake_req *req;
373 
374 	req = handshake_req_alloc(&tls_handshake_proto, flags);
375 	if (!req)
376 		return -ENOMEM;
377 	treq = tls_handshake_req_init(req, args);
378 	treq->th_type = HANDSHAKE_MSG_TYPE_SERVERHELLO;
379 	treq->th_auth_mode = HANDSHAKE_AUTH_X509;
380 	treq->th_certificate = args->ta_my_cert;
381 	treq->th_privkey = args->ta_my_privkey;
382 
383 	return handshake_req_submit(args->ta_sock, req, flags);
384 }
385 EXPORT_SYMBOL(tls_server_hello_x509);
386 
387 /**
388  * tls_server_hello_psk - request a server TLS handshake on a socket
389  * @args: socket and handshake parameters for this request
390  * @flags: memory allocation control flags
391  *
392  * Return values:
393  *   %0: Handshake request enqueue; ->done will be called when complete
394  *   %-ESRCH: No user agent is available
395  *   %-ENOMEM: Memory allocation failed
396  */
397 int tls_server_hello_psk(const struct tls_handshake_args *args, gfp_t flags)
398 {
399 	struct tls_handshake_req *treq;
400 	struct handshake_req *req;
401 
402 	req = handshake_req_alloc(&tls_handshake_proto, flags);
403 	if (!req)
404 		return -ENOMEM;
405 	treq = tls_handshake_req_init(req, args);
406 	treq->th_type = HANDSHAKE_MSG_TYPE_SERVERHELLO;
407 	treq->th_auth_mode = HANDSHAKE_AUTH_PSK;
408 	treq->th_num_peerids = 1;
409 	treq->th_peerid[0] = args->ta_my_peerids[0];
410 
411 	return handshake_req_submit(args->ta_sock, req, flags);
412 }
413 EXPORT_SYMBOL(tls_server_hello_psk);
414 
415 /**
416  * tls_handshake_cancel - cancel a pending handshake
417  * @sk: socket on which there is an ongoing handshake
418  *
419  * Request cancellation races with request completion. To determine
420  * who won, callers examine the return value from this function.
421  *
422  * Return values:
423  *   %true - Uncompleted handshake request was canceled
424  *   %false - Handshake request already completed or not found
425  */
426 bool tls_handshake_cancel(struct sock *sk)
427 {
428 	return handshake_req_cancel(sk);
429 }
430 EXPORT_SYMBOL(tls_handshake_cancel);
431 
432 /**
433  * tls_handshake_close - send a Closure alert
434  * @sock: an open socket
435  *
436  */
437 void tls_handshake_close(struct socket *sock)
438 {
439 	struct handshake_req *req;
440 
441 	req = handshake_req_hash_lookup(sock->sk);
442 	if (!req)
443 		return;
444 	if (!test_and_clear_bit(HANDSHAKE_F_REQ_SESSION, &req->hr_flags))
445 		return;
446 	tls_alert_send(sock, TLS_ALERT_LEVEL_WARNING,
447 		       TLS_ALERT_DESC_CLOSE_NOTIFY);
448 }
449 EXPORT_SYMBOL(tls_handshake_close);
450