1/*-
2 * Copyright (c) 1999-2002, 2009 Robert N. M. Watson
3 * Copyright (c) 2001 Ilmar S. Habibulin
4 * Copyright (c) 2001-2005 Networks Associates Technology, Inc.
5 * Copyright (c) 2005-2006 SPARTA, Inc.
6 * Copyright (c) 2008 Apple Inc.
7 * All rights reserved.
8 *
9 * This software was developed by Robert Watson and Ilmar Habibulin for the
10 * TrustedBSD Project.
11 *
12 * This software was developed for the FreeBSD Project in part by McAfee
13 * Research, the Technology Research Division of Network Associates, Inc.
14 * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
15 * DARPA CHATS research program.
16 *
17 * This software was enhanced by SPARTA ISSO under SPAWAR contract
18 * N66001-04-C-6019 ("SEFOS").
19 *
20 * This software was developed at the University of Cambridge Computer
21 * Laboratory with support from a grant from Google, Inc.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the above copyright
27 *    notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 *    notice, this list of conditions and the following disclaimer in the
30 *    documentation and/or other materials provided with the distribution.
31 *
32 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42 * SUCH DAMAGE.
43 */
44
45#include <sys/cdefs.h>
46__FBSDID("$FreeBSD$");
47
48#include "opt_kdtrace.h"
49#include "opt_mac.h"
50
51#include <sys/param.h>
52#include <sys/kernel.h>
53#include <sys/lock.h>
54#include <sys/malloc.h>
55#include <sys/mutex.h>
56#include <sys/mac.h>
57#include <sys/sbuf.h>
58#include <sys/sdt.h>
59#include <sys/systm.h>
60#include <sys/mount.h>
61#include <sys/file.h>
62#include <sys/namei.h>
63#include <sys/protosw.h>
64#include <sys/socket.h>
65#include <sys/socketvar.h>
66#include <sys/sysctl.h>
67
68#include <net/bpfdesc.h>
69#include <net/if.h>
70#include <net/if_var.h>
71
72#include <netinet/in.h>
73#include <netinet/in_pcb.h>
74#include <netinet/ip_var.h>
75
76#include <security/mac/mac_framework.h>
77#include <security/mac/mac_internal.h>
78#include <security/mac/mac_policy.h>
79
80/*
81 * Currently, sockets hold two labels: the label of the socket itself, and a
82 * peer label, which may be used by policies to hold a copy of the label of
83 * any remote endpoint.
84 *
85 * Possibly, this peer label should be maintained at the protocol layer
86 * (inpcb, unpcb, etc), as this would allow protocol-aware code to maintain
87 * the label consistently.  For example, it might be copied live from a
88 * remote socket for UNIX domain sockets rather than keeping a local copy on
89 * this endpoint, but be cached and updated based on packets received for
90 * TCP/IP.
91 *
92 * Unlike with many other object types, the lock protecting MAC labels on
93 * sockets (the socket lock) is not frequently held at the points in code
94 * where socket-related checks are called.  The MAC Framework acquires the
95 * lock over some entry points in order to enforce atomicity (such as label
96 * copies) but in other cases the policy modules will have to acquire the
97 * lock themselves if they use labels.  This approach (a) avoids lock
98 * acquisitions when policies don't require labels and (b) solves a number of
99 * potential lock order issues when multiple sockets are used in the same
100 * entry point.
101 */
102
103struct label *
104mac_socket_label_alloc(int flag)
105{
106	struct label *label;
107	int error;
108
109	label = mac_labelzone_alloc(flag);
110	if (label == NULL)
111		return (NULL);
112
113	if (flag & M_WAITOK)
114		MAC_POLICY_CHECK(socket_init_label, label, flag);
115	else
116		MAC_POLICY_CHECK_NOSLEEP(socket_init_label, label, flag);
117	if (error) {
118		MAC_POLICY_PERFORM_NOSLEEP(socket_destroy_label, label);
119		mac_labelzone_free(label);
120		return (NULL);
121	}
122	return (label);
123}
124
125static struct label *
126mac_socketpeer_label_alloc(int flag)
127{
128	struct label *label;
129	int error;
130
131	label = mac_labelzone_alloc(flag);
132	if (label == NULL)
133		return (NULL);
134
135	if (flag & M_WAITOK)
136		MAC_POLICY_CHECK(socketpeer_init_label, label, flag);
137	else
138		MAC_POLICY_CHECK_NOSLEEP(socketpeer_init_label, label, flag);
139	if (error) {
140		MAC_POLICY_PERFORM_NOSLEEP(socketpeer_destroy_label, label);
141		mac_labelzone_free(label);
142		return (NULL);
143	}
144	return (label);
145}
146
147int
148mac_socket_init(struct socket *so, int flag)
149{
150
151	if (mac_labeled & MPC_OBJECT_SOCKET) {
152		so->so_label = mac_socket_label_alloc(flag);
153		if (so->so_label == NULL)
154			return (ENOMEM);
155		so->so_peerlabel = mac_socketpeer_label_alloc(flag);
156		if (so->so_peerlabel == NULL) {
157			mac_socket_label_free(so->so_label);
158			so->so_label = NULL;
159			return (ENOMEM);
160		}
161	} else {
162		so->so_label = NULL;
163		so->so_peerlabel = NULL;
164	}
165	return (0);
166}
167
168void
169mac_socket_label_free(struct label *label)
170{
171
172	MAC_POLICY_PERFORM_NOSLEEP(socket_destroy_label, label);
173	mac_labelzone_free(label);
174}
175
176static void
177mac_socketpeer_label_free(struct label *label)
178{
179
180	MAC_POLICY_PERFORM_NOSLEEP(socketpeer_destroy_label, label);
181	mac_labelzone_free(label);
182}
183
184void
185mac_socket_destroy(struct socket *so)
186{
187
188	if (so->so_label != NULL) {
189		mac_socket_label_free(so->so_label);
190		so->so_label = NULL;
191		mac_socketpeer_label_free(so->so_peerlabel);
192		so->so_peerlabel = NULL;
193	}
194}
195
196void
197mac_socket_copy_label(struct label *src, struct label *dest)
198{
199
200	MAC_POLICY_PERFORM_NOSLEEP(socket_copy_label, src, dest);
201}
202
203int
204mac_socket_externalize_label(struct label *label, char *elements,
205    char *outbuf, size_t outbuflen)
206{
207	int error;
208
209	MAC_POLICY_EXTERNALIZE(socket, label, elements, outbuf, outbuflen);
210
211	return (error);
212}
213
214static int
215mac_socketpeer_externalize_label(struct label *label, char *elements,
216    char *outbuf, size_t outbuflen)
217{
218	int error;
219
220	MAC_POLICY_EXTERNALIZE(socketpeer, label, elements, outbuf,
221	    outbuflen);
222
223	return (error);
224}
225
226int
227mac_socket_internalize_label(struct label *label, char *string)
228{
229	int error;
230
231	MAC_POLICY_INTERNALIZE(socket, label, string);
232
233	return (error);
234}
235
236void
237mac_socket_create(struct ucred *cred, struct socket *so)
238{
239
240	MAC_POLICY_PERFORM_NOSLEEP(socket_create, cred, so, so->so_label);
241}
242
243void
244mac_socket_newconn(struct socket *oldso, struct socket *newso)
245{
246
247	MAC_POLICY_PERFORM_NOSLEEP(socket_newconn, oldso, oldso->so_label,
248	    newso, newso->so_label);
249}
250
251static void
252mac_socket_relabel(struct ucred *cred, struct socket *so,
253    struct label *newlabel)
254{
255
256	SOCK_LOCK_ASSERT(so);
257
258	MAC_POLICY_PERFORM_NOSLEEP(socket_relabel, cred, so, so->so_label,
259	    newlabel);
260}
261
262void
263mac_socketpeer_set_from_mbuf(struct mbuf *m, struct socket *so)
264{
265	struct label *label;
266
267	if (mac_policy_count == 0)
268		return;
269
270	label = mac_mbuf_to_label(m);
271
272	MAC_POLICY_PERFORM_NOSLEEP(socketpeer_set_from_mbuf, m, label, so,
273	    so->so_peerlabel);
274}
275
276void
277mac_socketpeer_set_from_socket(struct socket *oldso, struct socket *newso)
278{
279
280	if (mac_policy_count == 0)
281		return;
282
283	MAC_POLICY_PERFORM_NOSLEEP(socketpeer_set_from_socket, oldso,
284	    oldso->so_label, newso, newso->so_peerlabel);
285}
286
287void
288mac_socket_create_mbuf(struct socket *so, struct mbuf *m)
289{
290	struct label *label;
291
292	if (mac_policy_count == 0)
293		return;
294
295	label = mac_mbuf_to_label(m);
296
297	MAC_POLICY_PERFORM_NOSLEEP(socket_create_mbuf, so, so->so_label, m,
298	    label);
299}
300
301MAC_CHECK_PROBE_DEFINE2(socket_check_accept, "struct ucred *",
302    "struct socket *");
303
304int
305mac_socket_check_accept(struct ucred *cred, struct socket *so)
306{
307	int error;
308
309	MAC_POLICY_CHECK_NOSLEEP(socket_check_accept, cred, so,
310	    so->so_label);
311	MAC_CHECK_PROBE2(socket_check_accept, error, cred, so);
312
313	return (error);
314}
315
316MAC_CHECK_PROBE_DEFINE3(socket_check_bind, "struct ucred *",
317    "struct socket *", "struct sockaddr *");
318
319int
320mac_socket_check_bind(struct ucred *cred, struct socket *so,
321    struct sockaddr *sa)
322{
323	int error;
324
325	MAC_POLICY_CHECK_NOSLEEP(socket_check_bind, cred, so, so->so_label,
326	    sa);
327	MAC_CHECK_PROBE3(socket_check_bind, error, cred, so, sa);
328
329	return (error);
330}
331
332MAC_CHECK_PROBE_DEFINE3(socket_check_connect, "struct ucred *",
333    "struct socket *", "struct sockaddr *");
334
335int
336mac_socket_check_connect(struct ucred *cred, struct socket *so,
337    struct sockaddr *sa)
338{
339	int error;
340
341	MAC_POLICY_CHECK_NOSLEEP(socket_check_connect, cred, so,
342	    so->so_label, sa);
343	MAC_CHECK_PROBE3(socket_check_connect, error, cred, so, sa);
344
345	return (error);
346}
347
348MAC_CHECK_PROBE_DEFINE4(socket_check_create, "struct ucred *", "int", "int",
349    "int");
350
351int
352mac_socket_check_create(struct ucred *cred, int domain, int type, int proto)
353{
354	int error;
355
356	MAC_POLICY_CHECK_NOSLEEP(socket_check_create, cred, domain, type,
357	    proto);
358	MAC_CHECK_PROBE4(socket_check_create, error, cred, domain, type,
359	    proto);
360
361	return (error);
362}
363
364MAC_CHECK_PROBE_DEFINE2(socket_check_deliver, "struct socket *",
365    "struct mbuf *");
366
367int
368mac_socket_check_deliver(struct socket *so, struct mbuf *m)
369{
370	struct label *label;
371	int error;
372
373	if (mac_policy_count == 0)
374		return (0);
375
376	label = mac_mbuf_to_label(m);
377
378	MAC_POLICY_CHECK_NOSLEEP(socket_check_deliver, so, so->so_label, m,
379	    label);
380	MAC_CHECK_PROBE2(socket_check_deliver, error, so, m);
381
382	return (error);
383}
384
385MAC_CHECK_PROBE_DEFINE2(socket_check_listen, "struct ucred *",
386    "struct socket *");
387
388int
389mac_socket_check_listen(struct ucred *cred, struct socket *so)
390{
391	int error;
392
393	MAC_POLICY_CHECK_NOSLEEP(socket_check_listen, cred, so,
394	    so->so_label);
395	MAC_CHECK_PROBE2(socket_check_listen, error, cred, so);
396
397	return (error);
398}
399
400MAC_CHECK_PROBE_DEFINE2(socket_check_poll, "struct ucred *",
401    "struct socket *");
402
403int
404mac_socket_check_poll(struct ucred *cred, struct socket *so)
405{
406	int error;
407
408	MAC_POLICY_CHECK_NOSLEEP(socket_check_poll, cred, so, so->so_label);
409	MAC_CHECK_PROBE2(socket_check_poll, error, cred, so);
410
411	return (error);
412}
413
414MAC_CHECK_PROBE_DEFINE2(socket_check_receive, "struct ucred *",
415    "struct socket *");
416
417int
418mac_socket_check_receive(struct ucred *cred, struct socket *so)
419{
420	int error;
421
422	MAC_POLICY_CHECK_NOSLEEP(socket_check_receive, cred, so,
423	    so->so_label);
424	MAC_CHECK_PROBE2(socket_check_receive, error, cred, so);
425
426	return (error);
427}
428
429MAC_CHECK_PROBE_DEFINE3(socket_check_relabel, "struct ucred *",
430    "struct socket *", "struct label *");
431
432static int
433mac_socket_check_relabel(struct ucred *cred, struct socket *so,
434    struct label *newlabel)
435{
436	int error;
437
438	SOCK_LOCK_ASSERT(so);
439
440	MAC_POLICY_CHECK_NOSLEEP(socket_check_relabel, cred, so,
441	    so->so_label, newlabel);
442	MAC_CHECK_PROBE3(socket_check_relabel, error, cred, so, newlabel);
443
444	return (error);
445}
446
447MAC_CHECK_PROBE_DEFINE2(socket_check_send, "struct ucred *",
448    "struct socket *");
449
450int
451mac_socket_check_send(struct ucred *cred, struct socket *so)
452{
453	int error;
454
455	MAC_POLICY_CHECK_NOSLEEP(socket_check_send, cred, so, so->so_label);
456	MAC_CHECK_PROBE2(socket_check_send, error, cred, so);
457
458	return (error);
459}
460
461MAC_CHECK_PROBE_DEFINE2(socket_check_stat, "struct ucred *",
462    "struct socket *");
463
464int
465mac_socket_check_stat(struct ucred *cred, struct socket *so)
466{
467	int error;
468
469	MAC_POLICY_CHECK_NOSLEEP(socket_check_stat, cred, so, so->so_label);
470	MAC_CHECK_PROBE2(socket_check_stat, error, cred, so);
471
472	return (error);
473}
474
475MAC_CHECK_PROBE_DEFINE2(socket_check_visible, "struct ucred *",
476    "struct socket *");
477
478int
479mac_socket_check_visible(struct ucred *cred, struct socket *so)
480{
481	int error;
482
483	MAC_POLICY_CHECK_NOSLEEP(socket_check_visible, cred, so,
484	    so->so_label);
485	MAC_CHECK_PROBE2(socket_check_visible, error, cred, so);
486
487	return (error);
488}
489
490int
491mac_socket_label_set(struct ucred *cred, struct socket *so,
492    struct label *label)
493{
494	int error;
495
496	/*
497	 * We acquire the socket lock when we perform the test and set, but
498	 * have to release it as the pcb code needs to acquire the pcb lock,
499	 * which will precede the socket lock in the lock order.  However,
500	 * this is fine, as any race will simply result in the inpcb being
501	 * refreshed twice, but still consistently, as the inpcb code will
502	 * acquire the socket lock before refreshing, holding both locks.
503	 */
504	SOCK_LOCK(so);
505	error = mac_socket_check_relabel(cred, so, label);
506	if (error) {
507		SOCK_UNLOCK(so);
508		return (error);
509	}
510
511	mac_socket_relabel(cred, so, label);
512	SOCK_UNLOCK(so);
513
514	/*
515	 * If the protocol has expressed interest in socket layer changes,
516	 * such as if it needs to propagate changes to a cached pcb label
517	 * from the socket, notify it of the label change while holding the
518	 * socket lock.
519	 */
520	if (so->so_proto->pr_usrreqs->pru_sosetlabel != NULL)
521		(so->so_proto->pr_usrreqs->pru_sosetlabel)(so);
522
523	return (0);
524}
525
526int
527mac_setsockopt_label(struct ucred *cred, struct socket *so, struct mac *mac)
528{
529	struct label *intlabel;
530	char *buffer;
531	int error;
532
533	if (!(mac_labeled & MPC_OBJECT_SOCKET))
534		return (EINVAL);
535
536	error = mac_check_structmac_consistent(mac);
537	if (error)
538		return (error);
539
540	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
541	error = copyinstr(mac->m_string, buffer, mac->m_buflen, NULL);
542	if (error) {
543		free(buffer, M_MACTEMP);
544		return (error);
545	}
546
547	intlabel = mac_socket_label_alloc(M_WAITOK);
548	error = mac_socket_internalize_label(intlabel, buffer);
549	free(buffer, M_MACTEMP);
550	if (error)
551		goto out;
552
553	error = mac_socket_label_set(cred, so, intlabel);
554out:
555	mac_socket_label_free(intlabel);
556	return (error);
557}
558
559int
560mac_getsockopt_label(struct ucred *cred, struct socket *so, struct mac *mac)
561{
562	char *buffer, *elements;
563	struct label *intlabel;
564	int error;
565
566	if (!(mac_labeled & MPC_OBJECT_SOCKET))
567		return (EINVAL);
568
569	error = mac_check_structmac_consistent(mac);
570	if (error)
571		return (error);
572
573	elements = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
574	error = copyinstr(mac->m_string, elements, mac->m_buflen, NULL);
575	if (error) {
576		free(elements, M_MACTEMP);
577		return (error);
578	}
579
580	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
581	intlabel = mac_socket_label_alloc(M_WAITOK);
582	SOCK_LOCK(so);
583	mac_socket_copy_label(so->so_label, intlabel);
584	SOCK_UNLOCK(so);
585	error = mac_socket_externalize_label(intlabel, elements, buffer,
586	    mac->m_buflen);
587	mac_socket_label_free(intlabel);
588	if (error == 0)
589		error = copyout(buffer, mac->m_string, strlen(buffer)+1);
590
591	free(buffer, M_MACTEMP);
592	free(elements, M_MACTEMP);
593
594	return (error);
595}
596
597int
598mac_getsockopt_peerlabel(struct ucred *cred, struct socket *so,
599    struct mac *mac)
600{
601	char *elements, *buffer;
602	struct label *intlabel;
603	int error;
604
605	if (!(mac_labeled & MPC_OBJECT_SOCKET))
606		return (EINVAL);
607
608	error = mac_check_structmac_consistent(mac);
609	if (error)
610		return (error);
611
612	elements = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
613	error = copyinstr(mac->m_string, elements, mac->m_buflen, NULL);
614	if (error) {
615		free(elements, M_MACTEMP);
616		return (error);
617	}
618
619	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
620	intlabel = mac_socket_label_alloc(M_WAITOK);
621	SOCK_LOCK(so);
622	mac_socket_copy_label(so->so_peerlabel, intlabel);
623	SOCK_UNLOCK(so);
624	error = mac_socketpeer_externalize_label(intlabel, elements, buffer,
625	    mac->m_buflen);
626	mac_socket_label_free(intlabel);
627	if (error == 0)
628		error = copyout(buffer, mac->m_string, strlen(buffer)+1);
629
630	free(buffer, M_MACTEMP);
631	free(elements, M_MACTEMP);
632
633	return (error);
634}
635