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