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: releng/10.0/sys/security/mac/mac_socket.c 193391 2009-06-03 18:46:28Z rwatson $");
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
103 struct label *
104 mac_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
125 static struct label *
126 mac_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
147 int
148 mac_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
168 void
169 mac_socket_label_free(struct label *label)
170 {
171
172 MAC_POLICY_PERFORM_NOSLEEP(socket_destroy_label, label);
173 mac_labelzone_free(label);
174 }
175
176 static void
177 mac_socketpeer_label_free(struct label *label)
178 {
179
180 MAC_POLICY_PERFORM_NOSLEEP(socketpeer_destroy_label, label);
181 mac_labelzone_free(label);
182 }
183
184 void
185 mac_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
196 void
197 mac_socket_copy_label(struct label *src, struct label *dest)
198 {
199
200 MAC_POLICY_PERFORM_NOSLEEP(socket_copy_label, src, dest);
201 }
202
203 int
204 mac_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
214 static int
215 mac_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
226 int
227 mac_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
236 void
237 mac_socket_create(struct ucred *cred, struct socket *so)
238 {
239
240 MAC_POLICY_PERFORM_NOSLEEP(socket_create, cred, so, so->so_label);
241 }
242
243 void
244 mac_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
251 static void
252 mac_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
262 void
263 mac_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
276 void
277 mac_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
287 void
288 mac_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
301 MAC_CHECK_PROBE_DEFINE2(socket_check_accept, "struct ucred *",
302 "struct socket *");
303
304 int
305 mac_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
316 MAC_CHECK_PROBE_DEFINE3(socket_check_bind, "struct ucred *",
317 "struct socket *", "struct sockaddr *");
318
319 int
320 mac_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
332 MAC_CHECK_PROBE_DEFINE3(socket_check_connect, "struct ucred *",
333 "struct socket *", "struct sockaddr *");
334
335 int
336 mac_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
348 MAC_CHECK_PROBE_DEFINE4(socket_check_create, "struct ucred *", "int", "int",
349 "int");
350
351 int
352 mac_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
364 MAC_CHECK_PROBE_DEFINE2(socket_check_deliver, "struct socket *",
365 "struct mbuf *");
366
367 int
368 mac_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
385 MAC_CHECK_PROBE_DEFINE2(socket_check_listen, "struct ucred *",
386 "struct socket *");
387
388 int
389 mac_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
400 MAC_CHECK_PROBE_DEFINE2(socket_check_poll, "struct ucred *",
401 "struct socket *");
402
403 int
404 mac_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
414 MAC_CHECK_PROBE_DEFINE2(socket_check_receive, "struct ucred *",
415 "struct socket *");
416
417 int
418 mac_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
429 MAC_CHECK_PROBE_DEFINE3(socket_check_relabel, "struct ucred *",
430 "struct socket *", "struct label *");
431
432 static int
433 mac_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
447 MAC_CHECK_PROBE_DEFINE2(socket_check_send, "struct ucred *",
448 "struct socket *");
449
450 int
451 mac_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
461 MAC_CHECK_PROBE_DEFINE2(socket_check_stat, "struct ucred *",
462 "struct socket *");
463
464 int
465 mac_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
475 MAC_CHECK_PROBE_DEFINE2(socket_check_visible, "struct ucred *",
476 "struct socket *");
477
478 int
479 mac_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
490 int
491 mac_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
526 int
527 mac_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);
554 out:
555 mac_socket_label_free(intlabel);
556 return (error);
557 }
558
559 int
560 mac_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
597 int
598 mac_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 }
Cache object: 6846995472f34633813fd25cbf7d9300
|