xref: /netbsd-src/sys/netipsec/keysock.c (revision 3117ece4fc4a4ca4489ba793710b60b0d26bab6c) 
1 /*	$NetBSD: keysock.c,v 1.72 2024/07/05 04:31:54 rin Exp $	*/
2 /*	$FreeBSD: keysock.c,v 1.3.2.1 2003/01/24 05:11:36 sam Exp $	*/
3 /*	$KAME: keysock.c,v 1.25 2001/08/13 20:07:41 itojun Exp $	*/
4 
5 /*
6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. Neither the name of the project nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: keysock.c,v 1.72 2024/07/05 04:31:54 rin Exp $");
36 
37 /* This code has derived from sys/net/rtsock.c on FreeBSD2.2.5 */
38 
39 #include <sys/types.h>
40 #include <sys/param.h>
41 #include <sys/domain.h>
42 #include <sys/errno.h>
43 #include <sys/kernel.h>
44 #include <sys/kmem.h>
45 #include <sys/mbuf.h>
46 #include <sys/protosw.h>
47 #include <sys/signalvar.h>
48 #include <sys/socket.h>
49 #include <sys/socketvar.h>
50 #include <sys/sysctl.h>
51 #include <sys/systm.h>
52 #include <sys/cpu.h>
53 #include <sys/syslog.h>
54 
55 #include <net/raw_cb.h>
56 #include <net/route.h>
57 
58 #include <net/pfkeyv2.h>
59 #include <netipsec/key.h>
60 #include <netipsec/keysock.h>
61 #include <netipsec/key_debug.h>
62 
63 #include <netipsec/ipsec_private.h>
64 
65 struct key_cb {
66 	int key_count;
67 	int any_count;
68 };
69 static struct key_cb key_cb;
70 
71 static struct sockaddr key_dst = {
72     .sa_len = 2,
73     .sa_family = PF_KEY,
74 };
75 static struct sockaddr key_src = {
76     .sa_len = 2,
77     .sa_family = PF_KEY,
78 };
79 
80 static const struct protosw keysw[];
81 
82 static int key_sendup0(struct rawcb *, struct mbuf *, int, int);
83 
84 int key_registered_sb_max = (2048 * MHLEN); /* XXX arbitrary */
85 
86 static kmutex_t *key_so_mtx;
87 static struct rawcbhead key_rawcb;
88 
89 void
90 key_init_so(void)
91 {
92 
93 	key_so_mtx = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
94 }
95 
96 static void
97 key_pr_init(void)
98 {
99 
100 	LIST_INIT(&key_rawcb);
101 }
102 
103 /*
104  * key_output()
105  */
106 static int
107 key_output(struct mbuf *m, struct socket *so)
108 {
109 	struct sadb_msg *msg;
110 	int len, error = 0;
111 	int s;
112 
113 	KASSERT(m != NULL);
114 
115 	{
116 		net_stat_ref_t ps = PFKEY_STAT_GETREF();
117 		_NET_STATINC_REF(ps, PFKEY_STAT_OUT_TOTAL);
118 		_NET_STATADD_REF(ps, PFKEY_STAT_OUT_BYTES, m->m_pkthdr.len);
119 		PFKEY_STAT_PUTREF();
120 	}
121 
122 	len = m->m_pkthdr.len;
123 	if (len < sizeof(struct sadb_msg)) {
124 		PFKEY_STATINC(PFKEY_STAT_OUT_TOOSHORT);
125 		error = EINVAL;
126 		goto end;
127 	}
128 
129 	if (m->m_len < sizeof(struct sadb_msg)) {
130 		if ((m = m_pullup(m, sizeof(struct sadb_msg))) == 0) {
131 			PFKEY_STATINC(PFKEY_STAT_OUT_NOMEM);
132 			error = ENOBUFS;
133 			goto end;
134 		}
135 	}
136 
137 	KASSERT((m->m_flags & M_PKTHDR) != 0);
138 
139 	if (KEYDEBUG_ON(KEYDEBUG_KEY_DUMP))
140 		kdebug_mbuf(__func__, m);
141 
142 	msg = mtod(m, struct sadb_msg *);
143 	PFKEY_STATINC(PFKEY_STAT_OUT_MSGTYPE + msg->sadb_msg_type);
144 	if (len != PFKEY_UNUNIT64(msg->sadb_msg_len)) {
145 		PFKEY_STATINC(PFKEY_STAT_OUT_INVLEN);
146 		error = EINVAL;
147 		goto end;
148 	}
149 
150 	/*XXX giant lock*/
151 	s = splsoftnet();
152 	error = key_parse(m, so);
153 	m = NULL;
154 	splx(s);
155 end:
156 	m_freem(m);
157 	return error;
158 }
159 
160 /*
161  * send message to the socket.
162  */
163 static int
164 key_sendup0(
165     struct rawcb *rp,
166     struct mbuf *m,
167     int promisc,
168     int sbprio
169 )
170 {
171 	int error;
172 	int ok;
173 
174 	if (promisc) {
175 		struct sadb_msg *pmsg;
176 
177 		M_PREPEND(m, sizeof(struct sadb_msg), M_DONTWAIT);
178 		if (m && m->m_len < sizeof(struct sadb_msg))
179 			m = m_pullup(m, sizeof(struct sadb_msg));
180 		if (!m) {
181 			PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
182 			return ENOBUFS;
183 		}
184 		m->m_pkthdr.len += sizeof(*pmsg);
185 
186 		pmsg = mtod(m, struct sadb_msg *);
187 		memset(pmsg, 0, sizeof(*pmsg));
188 		pmsg->sadb_msg_version = PF_KEY_V2;
189 		pmsg->sadb_msg_type = SADB_X_PROMISC;
190 		pmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
191 		/* pid and seq? */
192 
193 		PFKEY_STATINC(PFKEY_STAT_IN_MSGTYPE + pmsg->sadb_msg_type);
194 	}
195 
196 	if (sbprio == 0)
197 		ok = sbappendaddr(&rp->rcb_socket->so_rcv,
198 			       (struct sockaddr *)&key_src, m, NULL);
199 	else
200 		ok = sbappendaddrchain(&rp->rcb_socket->so_rcv,
201 			       (struct sockaddr *)&key_src, m, sbprio);
202 
203 	if (!ok) {
204 		log(LOG_WARNING,
205 		    "%s: couldn't send PF_KEY message to the socket\n",
206 		    __func__);
207 		PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
208 		m_freem(m);
209 		/* Don't call soroverflow because we're returning this
210 		 * error directly to the sender. */
211 		rp->rcb_socket->so_rcv.sb_overflowed++;
212 		error = ENOBUFS;
213 	} else {
214 		sorwakeup(rp->rcb_socket);
215 		error = 0;
216 	}
217 	return error;
218 }
219 
220 /* so can be NULL if target != KEY_SENDUP_ONE */
221 static int
222 _key_sendup_mbuf(struct socket *so, struct mbuf *m,
223 		int target/*, sbprio */)
224 {
225 	struct mbuf *n;
226 	struct keycb *kp;
227 	int sendup;
228 	struct rawcb *rp;
229 	int error = 0;
230 	int sbprio = 0; /* XXX should be a parameter */
231 
232 	KASSERT(m != NULL);
233 	KASSERT(so != NULL || target != KEY_SENDUP_ONE);
234 
235 	/*
236 	 * RFC 2367 says ACQUIRE and other kernel-generated messages
237 	 * are special. We treat all KEY_SENDUP_REGISTERED messages
238 	 * as special, delivering them to all registered sockets
239 	 * even if the socket is at or above its so->so_rcv.sb_max limits.
240 	 * The only constraint is that the  so_rcv data fall below
241 	 * key_registered_sb_max.
242 	 * Doing that check here avoids reworking every key_sendup_mbuf()
243 	 * in the short term. . The rework will be done after a technical
244 	 * conensus that this approach is appropriate.
245  	 */
246 	if (target == KEY_SENDUP_REGISTERED) {
247 		sbprio = SB_PRIO_BESTEFFORT;
248 	}
249 
250 	{
251 		net_stat_ref_t ps = PFKEY_STAT_GETREF();
252 		_NET_STATINC_REF(ps, PFKEY_STAT_IN_TOTAL);
253 		_NET_STATADD_REF(ps, PFKEY_STAT_IN_BYTES, m->m_pkthdr.len);
254 		PFKEY_STAT_PUTREF();
255 	}
256 	if (m->m_len < sizeof(struct sadb_msg)) {
257 #if 1
258 		m = m_pullup(m, sizeof(struct sadb_msg));
259 		if (m == NULL) {
260 			PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
261 			return ENOBUFS;
262 		}
263 #else
264 		/* don't bother pulling it up just for stats */
265 #endif
266 	}
267 	if (m->m_len >= sizeof(struct sadb_msg)) {
268 		struct sadb_msg *msg;
269 		msg = mtod(m, struct sadb_msg *);
270 		PFKEY_STATINC(PFKEY_STAT_IN_MSGTYPE + msg->sadb_msg_type);
271 	}
272 
273 	LIST_FOREACH(rp, &key_rawcb, rcb_list)
274 	{
275 		struct socket * kso = rp->rcb_socket;
276 		if (rp->rcb_proto.sp_family != PF_KEY)
277 			continue;
278 		if (rp->rcb_proto.sp_protocol
279 		 && rp->rcb_proto.sp_protocol != PF_KEY_V2) {
280 			continue;
281 		}
282 
283 		kp = (struct keycb *)rp;
284 
285 		/*
286 		 * If you are in promiscuous mode, and when you get broadcasted
287 		 * reply, you'll get two PF_KEY messages.
288 		 * (based on pf_key@inner.net message on 14 Oct 1998)
289 		 */
290 		if (((struct keycb *)rp)->kp_promisc) {
291 			if ((n = m_copym(m, 0, (int)M_COPYALL, M_DONTWAIT)) != NULL) {
292 				(void)key_sendup0(rp, n, 1, 0);
293 				n = NULL;
294 			}
295 		}
296 
297 		/* the exact target will be processed later */
298 		if (so && sotorawcb(so) == rp)
299 			continue;
300 
301 		sendup = 0;
302 		switch (target) {
303 		case KEY_SENDUP_ONE:
304 			/* the statement has no effect */
305 			if (so && sotorawcb(so) == rp)
306 				sendup++;
307 			break;
308 		case KEY_SENDUP_ALL:
309 			sendup++;
310 			break;
311 		case KEY_SENDUP_REGISTERED:
312 			if (kp->kp_registered) {
313 				if (kso->so_rcv.sb_cc <= key_registered_sb_max)
314 					sendup++;
315 			  	else
316 			  		printf("keysock: "
317 					       "registered sendup dropped, "
318 					       "sb_cc %ld max %d\n",
319 					       kso->so_rcv.sb_cc,
320 					       key_registered_sb_max);
321 			}
322 			break;
323 		}
324 		PFKEY_STATINC(PFKEY_STAT_IN_MSGTARGET + target);
325 
326 		if (!sendup)
327 			continue;
328 
329 		if ((n = m_copym(m, 0, (int)M_COPYALL, M_DONTWAIT)) == NULL) {
330 			m_freem(m);
331 			PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
332 			return ENOBUFS;
333 		}
334 
335 		if ((error = key_sendup0(rp, n, 0, 0)) != 0) {
336 			m_freem(m);
337 			return error;
338 		}
339 
340 		n = NULL;
341 	}
342 
343 	/* The 'later' time for processing the exact target has arrived */
344 	if (so) {
345 		error = key_sendup0(sotorawcb(so), m, 0, sbprio);
346 		m = NULL;
347 	} else {
348 		error = 0;
349 		m_freem(m);
350 	}
351 	return error;
352 }
353 
354 int
355 key_sendup_mbuf(struct socket *so, struct mbuf *m,
356 		int target/*, sbprio */)
357 {
358 	int error;
359 
360 	if (so == NULL)
361 		mutex_enter(key_so_mtx);
362 	else
363 		KASSERT(solocked(so));
364 
365 	error = _key_sendup_mbuf(so, m, target);
366 
367 	if (so == NULL)
368 		mutex_exit(key_so_mtx);
369 	return error;
370 }
371 
372 static int
373 key_attach(struct socket *so, int proto)
374 {
375 	struct keycb *kp;
376 	int s, error;
377 
378 	KASSERT(sotorawcb(so) == NULL);
379 	kp = kmem_zalloc(sizeof(*kp), KM_SLEEP);
380 	kp->kp_raw.rcb_len = sizeof(*kp);
381 	so->so_pcb = kp;
382 
383 	s = splsoftnet();
384 
385 	if (so->so_lock != key_so_mtx) {
386 		KASSERT(so->so_lock == NULL);
387 		mutex_obj_hold(key_so_mtx);
388 		so->so_lock = key_so_mtx;
389 		solock(so);
390 	}
391 
392 	error = raw_attach(so, proto, &key_rawcb);
393 	if (error) {
394 		PFKEY_STATINC(PFKEY_STAT_SOCKERR);
395 		kmem_free(kp, sizeof(*kp));
396 		so->so_pcb = NULL;
397 		goto out;
398 	}
399 
400 	kp->kp_promisc = kp->kp_registered = 0;
401 
402 	if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
403 		key_cb.key_count++;
404 	key_cb.any_count++;
405 	kp->kp_raw.rcb_laddr = &key_src;
406 	kp->kp_raw.rcb_faddr = &key_dst;
407 	soisconnected(so);
408 	so->so_options |= SO_USELOOPBACK;
409 out:
410 	KASSERT(solocked(so));
411 	splx(s);
412 	return error;
413 }
414 
415 static void
416 key_detach(struct socket *so)
417 {
418 	struct keycb *kp = (struct keycb *)sotorawcb(so);
419 	int s;
420 
421 	KASSERT(!cpu_softintr_p());
422 	KASSERT(solocked(so));
423 	KASSERT(kp != NULL);
424 
425 	s = splsoftnet();
426 	if (kp->kp_raw.rcb_proto.sp_protocol == PF_KEY) /* XXX: AF_KEY */
427 		key_cb.key_count--;
428 	key_cb.any_count--;
429 	key_freereg(so);
430 	raw_detach(so);
431 	splx(s);
432 }
433 
434 static int
435 key_accept(struct socket *so, struct sockaddr *nam)
436 {
437 	KASSERT(solocked(so));
438 
439 	panic("%s: unsupported", __func__);
440 
441 	return EOPNOTSUPP;
442 }
443 
444 static int
445 key_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
446 {
447 	KASSERT(solocked(so));
448 
449 	return EOPNOTSUPP;
450 }
451 
452 static int
453 key_listen(struct socket *so, struct lwp *l)
454 {
455 	KASSERT(solocked(so));
456 
457 	return EOPNOTSUPP;
458 }
459 
460 static int
461 key_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
462 {
463 	KASSERT(solocked(so));
464 
465 	return EOPNOTSUPP;
466 }
467 
468 static int
469 key_connect2(struct socket *so, struct socket *so2)
470 {
471 	KASSERT(solocked(so));
472 
473 	return EOPNOTSUPP;
474 }
475 
476 static int
477 key_disconnect(struct socket *so)
478 {
479 	struct rawcb *rp = sotorawcb(so);
480 	int s;
481 
482 	KASSERT(solocked(so));
483 	KASSERT(rp != NULL);
484 
485 	s = splsoftnet();
486 	soisdisconnected(so);
487 	raw_disconnect(rp);
488 	splx(s);
489 
490 	return 0;
491 }
492 
493 static int
494 key_shutdown(struct socket *so)
495 {
496 	int s;
497 
498 	KASSERT(solocked(so));
499 
500 	/*
501 	 * Mark the connection as being incapable of further input.
502 	 */
503 	s = splsoftnet();
504 	socantsendmore(so);
505 	splx(s);
506 
507 	return 0;
508 }
509 
510 static int
511 key_abort(struct socket *so)
512 {
513 	KASSERT(solocked(so));
514 
515 	panic("%s: unsupported", __func__);
516 
517 	return EOPNOTSUPP;
518 }
519 
520 static int
521 key_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)
522 {
523 	return EOPNOTSUPP;
524 }
525 
526 static int
527 key_stat(struct socket *so, struct stat *ub)
528 {
529 	KASSERT(solocked(so));
530 
531 	return 0;
532 }
533 
534 static int
535 key_peeraddr(struct socket *so, struct sockaddr *nam)
536 {
537 	struct rawcb *rp = sotorawcb(so);
538 
539 	KASSERT(solocked(so));
540 	KASSERT(rp != NULL);
541 	KASSERT(nam != NULL);
542 
543 	if (rp->rcb_faddr == NULL)
544 		return ENOTCONN;
545 
546 	raw_setpeeraddr(rp, nam);
547 	return 0;
548 }
549 
550 static int
551 key_sockaddr(struct socket *so, struct sockaddr *nam)
552 {
553 	struct rawcb *rp = sotorawcb(so);
554 
555 	KASSERT(solocked(so));
556 	KASSERT(rp != NULL);
557 	KASSERT(nam != NULL);
558 
559 	if (rp->rcb_faddr == NULL)
560 		return ENOTCONN;
561 
562 	raw_setsockaddr(rp, nam);
563 	return 0;
564 }
565 
566 static int
567 key_rcvd(struct socket *so, int flags, struct lwp *l)
568 {
569 	KASSERT(solocked(so));
570 
571 	return EOPNOTSUPP;
572 }
573 
574 static int
575 key_recvoob(struct socket *so, struct mbuf *m, int flags)
576 {
577 	KASSERT(solocked(so));
578 
579 	return EOPNOTSUPP;
580 }
581 
582 static int
583 key_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
584     struct mbuf *control, struct lwp *l)
585 {
586 	int error = 0;
587 	int s;
588 
589 	KASSERT(solocked(so));
590 	KASSERT(so->so_proto == &keysw[0]);
591 
592 	s = splsoftnet();
593 	error = raw_send(so, m, nam, control, l, &key_output);
594 	splx(s);
595 
596 	return error;
597 }
598 
599 static int
600 key_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
601 {
602 	KASSERT(solocked(so));
603 
604 	m_freem(m);
605 	m_freem(control);
606 
607 	return EOPNOTSUPP;
608 }
609 
610 static int
611 key_purgeif(struct socket *so, struct ifnet *ifa)
612 {
613 
614 	panic("%s: unsupported", __func__);
615 
616 	return EOPNOTSUPP;
617 }
618 
619 /*
620  * Definitions of protocols supported in the KEY domain.
621  */
622 
623 DOMAIN_DEFINE(keydomain);
624 
625 PR_WRAP_USRREQS(key)
626 #define	key_attach	key_attach_wrapper
627 #define	key_detach	key_detach_wrapper
628 #define	key_accept	key_accept_wrapper
629 #define	key_bind	key_bind_wrapper
630 #define	key_listen	key_listen_wrapper
631 #define	key_connect	key_connect_wrapper
632 #define	key_connect2	key_connect2_wrapper
633 #define	key_disconnect	key_disconnect_wrapper
634 #define	key_shutdown	key_shutdown_wrapper
635 #define	key_abort	key_abort_wrapper
636 #define	key_ioctl	key_ioctl_wrapper
637 #define	key_stat	key_stat_wrapper
638 #define	key_peeraddr	key_peeraddr_wrapper
639 #define	key_sockaddr	key_sockaddr_wrapper
640 #define	key_rcvd	key_rcvd_wrapper
641 #define	key_recvoob	key_recvoob_wrapper
642 #define	key_send	key_send_wrapper
643 #define	key_sendoob	key_sendoob_wrapper
644 #define	key_purgeif	key_purgeif_wrapper
645 
646 static const struct pr_usrreqs key_usrreqs = {
647 	.pr_attach	= key_attach,
648 	.pr_detach	= key_detach,
649 	.pr_accept	= key_accept,
650 	.pr_bind	= key_bind,
651 	.pr_listen	= key_listen,
652 	.pr_connect	= key_connect,
653 	.pr_connect2	= key_connect2,
654 	.pr_disconnect	= key_disconnect,
655 	.pr_shutdown	= key_shutdown,
656 	.pr_abort	= key_abort,
657 	.pr_ioctl	= key_ioctl,
658 	.pr_stat	= key_stat,
659 	.pr_peeraddr	= key_peeraddr,
660 	.pr_sockaddr	= key_sockaddr,
661 	.pr_rcvd	= key_rcvd,
662 	.pr_recvoob	= key_recvoob,
663 	.pr_send	= key_send,
664 	.pr_sendoob	= key_sendoob,
665 	.pr_purgeif	= key_purgeif,
666 };
667 
668 static const struct protosw keysw[] = {
669     {
670 	.pr_type = SOCK_RAW,
671 	.pr_domain = &keydomain,
672 	.pr_protocol = PF_KEY_V2,
673 	.pr_flags = PR_ATOMIC|PR_ADDR,
674 	.pr_ctlinput = raw_ctlinput,
675 	.pr_usrreqs = &key_usrreqs,
676 	.pr_init = key_pr_init,
677     }
678 };
679 
680 struct domain keydomain = {
681     .dom_family = PF_KEY,
682     .dom_name = "key",
683     .dom_init = key_init,
684     .dom_protosw = keysw,
685     .dom_protoswNPROTOSW = &keysw[__arraycount(keysw)],
686 };
687