sys/security/mac/mac_socket.c

   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
 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 }