sys/security/mac_mls/mac_mls.c

   1 /*-
   2  * Copyright (c) 1999-2002 Robert N. M. Watson
   3  * Copyright (c) 2001-2005 McAfee, Inc.
   4  * All rights reserved.
   5  *
   6  * This software was developed by Robert Watson for the TrustedBSD Project.
   7  *
   8  * This software was developed for the FreeBSD Project in part by McAfee
   9  * Research, the Security Research Division of McAfee, Inc. under
  10  * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA
  11  * CHATS research program.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $FreeBSD$
  35  */
  36
  37 /*
  38  * Developed by the TrustedBSD Project.
  39  *
  40  * MLS fixed label mandatory confidentiality policy.
  41  */
  42
  43 #include <sys/types.h>
  44 #include <sys/param.h>
  45 #include <sys/acl.h>
  46 #include <sys/conf.h>
  47 #include <sys/extattr.h>
  48 #include <sys/kernel.h>
  49 #include <sys/ksem.h>
  50 #include <sys/mman.h>
  51 #include <sys/malloc.h>
  52 #include <sys/mount.h>
  53 #include <sys/proc.h>
  54 #include <sys/sbuf.h>
  55 #include <sys/systm.h>
  56 #include <sys/sysproto.h>
  57 #include <sys/sysent.h>
  58 #include <sys/systm.h>
  59 #include <sys/vnode.h>
  60 #include <sys/file.h>
  61 #include <sys/socket.h>
  62 #include <sys/socketvar.h>
  63 #include <sys/pipe.h>
  64 #include <sys/sx.h>
  65 #include <sys/sysctl.h>
  66 #include <sys/msg.h>
  67 #include <sys/sem.h>
  68 #include <sys/shm.h>
  69
  70 #include <fs/devfs/devfs.h>
  71
  72 #include <net/bpfdesc.h>
  73 #include <net/if.h>
  74 #include <net/if_types.h>
  75 #include <net/if_var.h>
  76
  77 #include <netinet/in.h>
  78 #include <netinet/in_pcb.h>
  79 #include <netinet/ip_var.h>
  80
  81 #include <vm/uma.h>
  82 #include <vm/vm.h>
  83
  84 #include <security/mac/mac_policy.h>
  85 #include <security/mac_mls/mac_mls.h>
  86
  87 SYSCTL_DECL(_security_mac);
  88
  89 SYSCTL_NODE(_security_mac, OID_AUTO, mls, CTLFLAG_RW, 0,
  90     "TrustedBSD mac_mls policy controls");
  91
  92 static int      mls_label_size = sizeof(struct mac_mls);
  93 SYSCTL_INT(_security_mac_mls, OID_AUTO, label_size, CTLFLAG_RD,
  94     &mls_label_size, 0, "Size of struct mac_mls");
  95
  96 static int      mls_enabled = 1;
  97 SYSCTL_INT(_security_mac_mls, OID_AUTO, enabled, CTLFLAG_RW, &mls_enabled, 0,
  98     "Enforce MAC/MLS policy");
  99 TUNABLE_INT("security.mac.mls.enabled", &mls_enabled);
 100
 101 static int      destroyed_not_inited;
 102 SYSCTL_INT(_security_mac_mls, OID_AUTO, destroyed_not_inited, CTLFLAG_RD,
 103     &destroyed_not_inited, 0, "Count of labels destroyed but not inited");
 104
 105 static int      ptys_equal = 0;
 106 SYSCTL_INT(_security_mac_mls, OID_AUTO, ptys_equal, CTLFLAG_RW,
 107     &ptys_equal, 0, "Label pty devices as mls/equal on create");
 108 TUNABLE_INT("security.mac.mls.ptys_equal", &ptys_equal);
 109
 110 static int      revocation_enabled = 0;
 111 SYSCTL_INT(_security_mac_mls, OID_AUTO, revocation_enabled, CTLFLAG_RW,
 112     &revocation_enabled, 0, "Revoke access to objects on relabel");
 113 TUNABLE_INT("security.mac.mls.revocation_enabled", &revocation_enabled);
 114
 115 static int      max_compartments = MAC_MLS_MAX_COMPARTMENTS;
 116 SYSCTL_INT(_security_mac_mls, OID_AUTO, max_compartments, CTLFLAG_RD,
 117     &max_compartments, 0, "Maximum compartments the policy supports");
 118
 119 static int      mls_slot;
 120 #define SLOT(l) ((struct mac_mls *)mac_label_get((l), mls_slot))
 121 #define SLOT_SET(l, val) mac_label_set((l), mls_slot, (uintptr_t)(val))
 122
 123 static uma_zone_t       zone_mls;
 124
 125 static __inline int
 126 mls_bit_set_empty(u_char *set) {
 127         int i;
 128
 129         for (i = 0; i < MAC_MLS_MAX_COMPARTMENTS >> 3; i++)
 130                 if (set[i] != 0)
 131                         return (0);
 132         return (1);
 133 }
 134
 135 static struct mac_mls *
 136 mls_alloc(int flag)
 137 {
 138
 139         return (uma_zalloc(zone_mls, flag | M_ZERO));
 140 }
 141
 142 static void
 143 mls_free(struct mac_mls *mm)
 144 {
 145
 146         if (mm != NULL)
 147                 uma_zfree(zone_mls, mm);
 148         else
 149                 atomic_add_int(&destroyed_not_inited, 1);
 150 }
 151
 152 static int
 153 mls_atmostflags(struct mac_mls *mm, int flags)
 154 {
 155
 156         if ((mm->mm_flags & flags) != mm->mm_flags)
 157                 return (EINVAL);
 158         return (0);
 159 }
 160
 161 static int
 162 mls_dominate_element(struct mac_mls_element *a, struct mac_mls_element *b)
 163 {
 164         int bit;
 165
 166         switch (a->mme_type) {
 167         case MAC_MLS_TYPE_EQUAL:
 168         case MAC_MLS_TYPE_HIGH:
 169                 return (1);
 170
 171         case MAC_MLS_TYPE_LOW:
 172                 switch (b->mme_type) {
 173                 case MAC_MLS_TYPE_LEVEL:
 174                 case MAC_MLS_TYPE_HIGH:
 175                         return (0);
 176
 177                 case MAC_MLS_TYPE_EQUAL:
 178                 case MAC_MLS_TYPE_LOW:
 179                         return (1);
 180
 181                 default:
 182                         panic("mls_dominate_element: b->mme_type invalid");
 183                 }
 184
 185         case MAC_MLS_TYPE_LEVEL:
 186                 switch (b->mme_type) {
 187                 case MAC_MLS_TYPE_EQUAL:
 188                 case MAC_MLS_TYPE_LOW:
 189                         return (1);
 190
 191                 case MAC_MLS_TYPE_HIGH:
 192                         return (0);
 193
 194                 case MAC_MLS_TYPE_LEVEL:
 195                         for (bit = 1; bit <= MAC_MLS_MAX_COMPARTMENTS; bit++)
 196                                 if (!MAC_MLS_BIT_TEST(bit,
 197                                     a->mme_compartments) &&
 198                                     MAC_MLS_BIT_TEST(bit, b->mme_compartments))
 199                                         return (0);
 200                         return (a->mme_level >= b->mme_level);
 201
 202                 default:
 203                         panic("mls_dominate_element: b->mme_type invalid");
 204                 }
 205
 206         default:
 207                 panic("mls_dominate_element: a->mme_type invalid");
 208         }
 209
 210         return (0);
 211 }
 212
 213 static int
 214 mls_range_in_range(struct mac_mls *rangea, struct mac_mls *rangeb)
 215 {
 216
 217         return (mls_dominate_element(&rangeb->mm_rangehigh,
 218             &rangea->mm_rangehigh) &&
 219             mls_dominate_element(&rangea->mm_rangelow,
 220             &rangeb->mm_rangelow));
 221 }
 222
 223 static int
 224 mls_effective_in_range(struct mac_mls *effective, struct mac_mls *range)
 225 {
 226
 227         KASSERT((effective->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 228             ("mls_effective_in_range: a not effective"));
 229         KASSERT((range->mm_flags & MAC_MLS_FLAG_RANGE) != 0,
 230             ("mls_effective_in_range: b not range"));
 231
 232         return (mls_dominate_element(&range->mm_rangehigh,
 233             &effective->mm_effective) &&
 234             mls_dominate_element(&effective->mm_effective,
 235             &range->mm_rangelow));
 236
 237         return (1);
 238 }
 239
 240 static int
 241 mls_dominate_effective(struct mac_mls *a, struct mac_mls *b)
 242 {
 243         KASSERT((a->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 244             ("mls_dominate_effective: a not effective"));
 245         KASSERT((b->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 246             ("mls_dominate_effective: b not effective"));
 247
 248         return (mls_dominate_element(&a->mm_effective, &b->mm_effective));
 249 }
 250
 251 static int
 252 mls_equal_element(struct mac_mls_element *a, struct mac_mls_element *b)
 253 {
 254
 255         if (a->mme_type == MAC_MLS_TYPE_EQUAL ||
 256             b->mme_type == MAC_MLS_TYPE_EQUAL)
 257                 return (1);
 258
 259         return (a->mme_type == b->mme_type && a->mme_level == b->mme_level);
 260 }
 261
 262 static int
 263 mls_equal_effective(struct mac_mls *a, struct mac_mls *b)
 264 {
 265
 266         KASSERT((a->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 267             ("mls_equal_effective: a not effective"));
 268         KASSERT((b->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 269             ("mls_equal_effective: b not effective"));
 270
 271         return (mls_equal_element(&a->mm_effective, &b->mm_effective));
 272 }
 273
 274 static int
 275 mls_contains_equal(struct mac_mls *mm)
 276 {
 277
 278         if (mm->mm_flags & MAC_MLS_FLAG_EFFECTIVE)
 279                 if (mm->mm_effective.mme_type == MAC_MLS_TYPE_EQUAL)
 280                         return (1);
 281
 282         if (mm->mm_flags & MAC_MLS_FLAG_RANGE) {
 283                 if (mm->mm_rangelow.mme_type == MAC_MLS_TYPE_EQUAL)
 284                         return (1);
 285                 if (mm->mm_rangehigh.mme_type == MAC_MLS_TYPE_EQUAL)
 286                         return (1);
 287         }
 288
 289         return (0);
 290 }
 291
 292 static int
 293 mls_subject_privileged(struct mac_mls *mm)
 294 {
 295
 296         KASSERT((mm->mm_flags & MAC_MLS_FLAGS_BOTH) == MAC_MLS_FLAGS_BOTH,
 297             ("mls_subject_privileged: subject doesn't have both labels"));
 298
 299         /* If the effective is EQUAL, it's ok. */
 300         if (mm->mm_effective.mme_type == MAC_MLS_TYPE_EQUAL)
 301                 return (0);
 302
 303         /* If either range endpoint is EQUAL, it's ok. */
 304         if (mm->mm_rangelow.mme_type == MAC_MLS_TYPE_EQUAL ||
 305             mm->mm_rangehigh.mme_type == MAC_MLS_TYPE_EQUAL)
 306                 return (0);
 307
 308         /* If the range is low-high, it's ok. */
 309         if (mm->mm_rangelow.mme_type == MAC_MLS_TYPE_LOW &&
 310             mm->mm_rangehigh.mme_type == MAC_MLS_TYPE_HIGH)
 311                 return (0);
 312
 313         /* It's not ok. */
 314         return (EPERM);
 315 }
 316
 317 static int
 318 mls_valid(struct mac_mls *mm)
 319 {
 320
 321         if (mm->mm_flags & MAC_MLS_FLAG_EFFECTIVE) {
 322                 switch (mm->mm_effective.mme_type) {
 323                 case MAC_MLS_TYPE_LEVEL:
 324                         break;
 325
 326                 case MAC_MLS_TYPE_EQUAL:
 327                 case MAC_MLS_TYPE_HIGH:
 328                 case MAC_MLS_TYPE_LOW:
 329                         if (mm->mm_effective.mme_level != 0 ||
 330                             !MAC_MLS_BIT_SET_EMPTY(
 331                             mm->mm_effective.mme_compartments))
 332                                 return (EINVAL);
 333                         break;
 334
 335                 default:
 336                         return (EINVAL);
 337                 }
 338         } else {
 339                 if (mm->mm_effective.mme_type != MAC_MLS_TYPE_UNDEF)
 340                         return (EINVAL);
 341         }
 342
 343         if (mm->mm_flags & MAC_MLS_FLAG_RANGE) {
 344                 switch (mm->mm_rangelow.mme_type) {
 345                 case MAC_MLS_TYPE_LEVEL:
 346                         break;
 347
 348                 case MAC_MLS_TYPE_EQUAL:
 349                 case MAC_MLS_TYPE_HIGH:
 350                 case MAC_MLS_TYPE_LOW:
 351                         if (mm->mm_rangelow.mme_level != 0 ||
 352                             !MAC_MLS_BIT_SET_EMPTY(
 353                             mm->mm_rangelow.mme_compartments))
 354                                 return (EINVAL);
 355                         break;
 356
 357                 default:
 358                         return (EINVAL);
 359                 }
 360
 361                 switch (mm->mm_rangehigh.mme_type) {
 362                 case MAC_MLS_TYPE_LEVEL:
 363                         break;
 364
 365                 case MAC_MLS_TYPE_EQUAL:
 366                 case MAC_MLS_TYPE_HIGH:
 367                 case MAC_MLS_TYPE_LOW:
 368                         if (mm->mm_rangehigh.mme_level != 0 ||
 369                             !MAC_MLS_BIT_SET_EMPTY(
 370                             mm->mm_rangehigh.mme_compartments))
 371                                 return (EINVAL);
 372                         break;
 373
 374                 default:
 375                         return (EINVAL);
 376                 }
 377                 if (!mls_dominate_element(&mm->mm_rangehigh,
 378                     &mm->mm_rangelow))
 379                         return (EINVAL);
 380         } else {
 381                 if (mm->mm_rangelow.mme_type != MAC_MLS_TYPE_UNDEF ||
 382                     mm->mm_rangehigh.mme_type != MAC_MLS_TYPE_UNDEF)
 383                         return (EINVAL);
 384         }
 385
 386         return (0);
 387 }
 388
 389 static void
 390 mls_set_range(struct mac_mls *mm, u_short typelow, u_short levellow,
 391     u_char *compartmentslow, u_short typehigh, u_short levelhigh,
 392     u_char *compartmentshigh)
 393 {
 394
 395         mm->mm_rangelow.mme_type = typelow;
 396         mm->mm_rangelow.mme_level = levellow;
 397         if (compartmentslow != NULL)
 398                 memcpy(mm->mm_rangelow.mme_compartments, compartmentslow,
 399                     sizeof(mm->mm_rangelow.mme_compartments));
 400         mm->mm_rangehigh.mme_type = typehigh;
 401         mm->mm_rangehigh.mme_level = levelhigh;
 402         if (compartmentshigh != NULL)
 403                 memcpy(mm->mm_rangehigh.mme_compartments, compartmentshigh,
 404                     sizeof(mm->mm_rangehigh.mme_compartments));
 405         mm->mm_flags |= MAC_MLS_FLAG_RANGE;
 406 }
 407
 408 static void
 409 mls_set_effective(struct mac_mls *mm, u_short type, u_short level,
 410     u_char *compartments)
 411 {
 412
 413         mm->mm_effective.mme_type = type;
 414         mm->mm_effective.mme_level = level;
 415         if (compartments != NULL)
 416                 memcpy(mm->mm_effective.mme_compartments, compartments,
 417                     sizeof(mm->mm_effective.mme_compartments));
 418         mm->mm_flags |= MAC_MLS_FLAG_EFFECTIVE;
 419 }
 420
 421 static void
 422 mls_copy_range(struct mac_mls *labelfrom, struct mac_mls *labelto)
 423 {
 424
 425         KASSERT((labelfrom->mm_flags & MAC_MLS_FLAG_RANGE) != 0,
 426             ("mls_copy_range: labelfrom not range"));
 427
 428         labelto->mm_rangelow = labelfrom->mm_rangelow;
 429         labelto->mm_rangehigh = labelfrom->mm_rangehigh;
 430         labelto->mm_flags |= MAC_MLS_FLAG_RANGE;
 431 }
 432
 433 static void
 434 mls_copy_effective(struct mac_mls *labelfrom, struct mac_mls *labelto)
 435 {
 436
 437         KASSERT((labelfrom->mm_flags & MAC_MLS_FLAG_EFFECTIVE) != 0,
 438             ("mls_copy_effective: labelfrom not effective"));
 439
 440         labelto->mm_effective = labelfrom->mm_effective;
 441         labelto->mm_flags |= MAC_MLS_FLAG_EFFECTIVE;
 442 }
 443
 444 static void
 445 mls_copy(struct mac_mls *source, struct mac_mls *dest)
 446 {
 447
 448         if (source->mm_flags & MAC_MLS_FLAG_EFFECTIVE)
 449                 mls_copy_effective(source, dest);
 450         if (source->mm_flags & MAC_MLS_FLAG_RANGE)
 451                 mls_copy_range(source, dest);
 452 }
 453
 454 /*
 455  * Policy module operations.
 456  */
 457 static void
 458 mls_init(struct mac_policy_conf *conf)
 459 {
 460
 461         zone_mls = uma_zcreate("mac_mls", sizeof(struct mac_mls), NULL,
 462             NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
 463 }
 464
 465 /*
 466  * Label operations.
 467  */
 468 static void
 469 mls_init_label(struct label *label)
 470 {
 471
 472         SLOT_SET(label, mls_alloc(M_WAITOK));
 473 }
 474
 475 static int
 476 mls_init_label_waitcheck(struct label *label, int flag)
 477 {
 478
 479         SLOT_SET(label, mls_alloc(flag));
 480         if (SLOT(label) == NULL)
 481                 return (ENOMEM);
 482
 483         return (0);
 484 }
 485
 486 static void
 487 mls_destroy_label(struct label *label)
 488 {
 489
 490         mls_free(SLOT(label));
 491         SLOT_SET(label, NULL);
 492 }
 493
 494 /*
 495  * mls_element_to_string() accepts an sbuf and MLS element.  It converts the
 496  * MLS element to a string and stores the result in the sbuf; if there isn't
 497  * space in the sbuf, -1 is returned.
 498  */
 499 static int
 500 mls_element_to_string(struct sbuf *sb, struct mac_mls_element *element)
 501 {
 502         int i, first;
 503
 504         switch (element->mme_type) {
 505         case MAC_MLS_TYPE_HIGH:
 506                 return (sbuf_printf(sb, "high"));
 507
 508         case MAC_MLS_TYPE_LOW:
 509                 return (sbuf_printf(sb, "low"));
 510
 511         case MAC_MLS_TYPE_EQUAL:
 512                 return (sbuf_printf(sb, "equal"));
 513
 514         case MAC_MLS_TYPE_LEVEL:
 515                 if (sbuf_printf(sb, "%d", element->mme_level) == -1)
 516                         return (-1);
 517
 518                 first = 1;
 519                 for (i = 1; i <= MAC_MLS_MAX_COMPARTMENTS; i++) {
 520                         if (MAC_MLS_BIT_TEST(i, element->mme_compartments)) {
 521                                 if (first) {
 522                                         if (sbuf_putc(sb, ':') == -1)
 523                                                 return (-1);
 524                                         if (sbuf_printf(sb, "%d", i) == -1)
 525                                                 return (-1);
 526                                         first = 0;
 527                                 } else {
 528                                         if (sbuf_printf(sb, "+%d", i) == -1)
 529                                                 return (-1);
 530                                 }
 531                         }
 532                 }
 533                 return (0);
 534
 535         default:
 536                 panic("mls_element_to_string: invalid type (%d)",
 537                     element->mme_type);
 538         }
 539 }
 540
 541 /*
 542  * mls_to_string() converts an MLS label to a string, and places the results
 543  * in the passed sbuf.  It returns 0 on success, or EINVAL if there isn't
 544  * room in the sbuf.  Note: the sbuf will be modified even in a failure case,
 545  * so the caller may need to revert the sbuf by restoring the offset if
 546  * that's undesired.
 547  */
 548 static int
 549 mls_to_string(struct sbuf *sb, struct mac_mls *mm)
 550 {
 551
 552         if (mm->mm_flags & MAC_MLS_FLAG_EFFECTIVE) {
 553                 if (mls_element_to_string(sb, &mm->mm_effective) == -1)
 554                         return (EINVAL);
 555         }
 556
 557         if (mm->mm_flags & MAC_MLS_FLAG_RANGE) {
 558                 if (sbuf_putc(sb, '(') == -1)
 559                         return (EINVAL);
 560
 561                 if (mls_element_to_string(sb, &mm->mm_rangelow) == -1)
 562                         return (EINVAL);
 563
 564                 if (sbuf_putc(sb, '-') == -1)
 565                         return (EINVAL);
 566
 567                 if (mls_element_to_string(sb, &mm->mm_rangehigh) == -1)
 568                         return (EINVAL);
 569
 570                 if (sbuf_putc(sb, ')') == -1)
 571                         return (EINVAL);
 572         }
 573
 574         return (0);
 575 }
 576
 577 static int
 578 mls_externalize_label(struct label *label, char *element_name,
 579     struct sbuf *sb, int *claimed)
 580 {
 581         struct mac_mls *mm;
 582
 583         if (strcmp(MAC_MLS_LABEL_NAME, element_name) != 0)
 584                 return (0);
 585
 586         (*claimed)++;
 587
 588         mm = SLOT(label);
 589
 590         return (mls_to_string(sb, mm));
 591 }
 592
 593 static int
 594 mls_parse_element(struct mac_mls_element *element, char *string)
 595 {
 596         char *compartment, *end, *level;
 597         int value;
 598
 599         if (strcmp(string, "high") == 0 || strcmp(string, "hi") == 0) {
 600                 element->mme_type = MAC_MLS_TYPE_HIGH;
 601                 element->mme_level = MAC_MLS_TYPE_UNDEF;
 602         } else if (strcmp(string, "low") == 0 || strcmp(string, "lo") == 0) {
 603                 element->mme_type = MAC_MLS_TYPE_LOW;
 604                 element->mme_level = MAC_MLS_TYPE_UNDEF;
 605         } else if (strcmp(string, "equal") == 0 ||
 606             strcmp(string, "eq") == 0) {
 607                 element->mme_type = MAC_MLS_TYPE_EQUAL;
 608                 element->mme_level = MAC_MLS_TYPE_UNDEF;
 609         } else {
 610                 element->mme_type = MAC_MLS_TYPE_LEVEL;
 611
 612                 /*
 613                  * Numeric level piece of the element.
 614                  */
 615                 level = strsep(&string, ":");
 616                 value = strtol(level, &end, 10);
 617                 if (end == level || *end != '\0')
 618                         return (EINVAL);
 619                 if (value < 0 || value > 65535)
 620                         return (EINVAL);
 621                 element->mme_level = value;
 622
 623                 /*
 624                  * Optional compartment piece of the element.  If none are
 625                  * included, we assume that the label has no compartments.
 626                  */
 627                 if (string == NULL)
 628                         return (0);
 629                 if (*string == '\0')
 630                         return (0);
 631
 632                 while ((compartment = strsep(&string, "+")) != NULL) {
 633                         value = strtol(compartment, &end, 10);
 634                         if (compartment == end || *end != '\0')
 635                                 return (EINVAL);
 636                         if (value < 1 || value > MAC_MLS_MAX_COMPARTMENTS)
 637                                 return (EINVAL);
 638                         MAC_MLS_BIT_SET(value, element->mme_compartments);
 639                 }
 640         }
 641
 642         return (0);
 643 }
 644
 645 /*
 646  * Note: destructively consumes the string, make a local copy before calling
 647  * if that's a problem.
 648  */
 649 static int
 650 mls_parse(struct mac_mls *mm, char *string)
 651 {
 652         char *rangehigh, *rangelow, *effective;
 653         int error;
 654
 655         effective = strsep(&string, "(");
 656         if (*effective == '\0')
 657                 effective = NULL;
 658
 659         if (string != NULL) {
 660                 rangelow = strsep(&string, "-");
 661                 if (string == NULL)
 662                         return (EINVAL);
 663                 rangehigh = strsep(&string, ")");
 664                 if (string == NULL)
 665                         return (EINVAL);
 666                 if (*string != '\0')
 667                         return (EINVAL);
 668         } else {
 669                 rangelow = NULL;
 670                 rangehigh = NULL;
 671         }
 672
 673         KASSERT((rangelow != NULL && rangehigh != NULL) ||
 674             (rangelow == NULL && rangehigh == NULL),
 675             ("mls_parse: range mismatch"));
 676
 677         bzero(mm, sizeof(*mm));
 678         if (effective != NULL) {
 679                 error = mls_parse_element(&mm->mm_effective, effective);
 680                 if (error)
 681                         return (error);
 682                 mm->mm_flags |= MAC_MLS_FLAG_EFFECTIVE;
 683         }
 684
 685         if (rangelow != NULL) {
 686                 error = mls_parse_element(&mm->mm_rangelow, rangelow);
 687                 if (error)
 688                         return (error);
 689                 error = mls_parse_element(&mm->mm_rangehigh, rangehigh);
 690                 if (error)
 691                         return (error);
 692                 mm->mm_flags |= MAC_MLS_FLAG_RANGE;
 693         }
 694
 695         error = mls_valid(mm);
 696         if (error)
 697                 return (error);
 698
 699         return (0);
 700 }
 701
 702 static int
 703 mls_internalize_label(struct label *label, char *element_name,
 704     char *element_data, int *claimed)
 705 {
 706         struct mac_mls *mm, mm_temp;
 707         int error;
 708
 709         if (strcmp(MAC_MLS_LABEL_NAME, element_name) != 0)
 710                 return (0);
 711
 712         (*claimed)++;
 713
 714         error = mls_parse(&mm_temp, element_data);
 715         if (error)
 716                 return (error);
 717
 718         mm = SLOT(label);
 719         *mm = mm_temp;
 720
 721         return (0);
 722 }
 723
 724 static void
 725 mls_copy_label(struct label *src, struct label *dest)
 726 {
 727
 728         *SLOT(dest) = *SLOT(src);
 729 }
 730
 731 /*
 732  * Labeling event operations: file system objects, and things that look a lot
 733  * like file system objects.
 734  */
 735 static void
 736 mls_create_devfs_device(struct ucred *cred, struct mount *mp,
 737     struct cdev *dev, struct devfs_dirent *de, struct label *delabel)
 738 {
 739         struct mac_mls *mm;
 740         int mls_type;
 741
 742         mm = SLOT(delabel);
 743         if (strcmp(dev->si_name, "null") == 0 ||
 744             strcmp(dev->si_name, "zero") == 0 ||
 745             strcmp(dev->si_name, "random") == 0 ||
 746             strncmp(dev->si_name, "fd/", strlen("fd/")) == 0)
 747                 mls_type = MAC_MLS_TYPE_EQUAL;
 748         else if (strcmp(dev->si_name, "kmem") == 0 ||
 749             strcmp(dev->si_name, "mem") == 0)
 750                 mls_type = MAC_MLS_TYPE_HIGH;
 751         else if (ptys_equal &&
 752             (strncmp(dev->si_name, "ttyp", strlen("ttyp")) == 0 ||
 753             strncmp(dev->si_name, "ptyp", strlen("ptyp")) == 0))
 754                 mls_type = MAC_MLS_TYPE_EQUAL;
 755         else
 756                 mls_type = MAC_MLS_TYPE_LOW;
 757         mls_set_effective(mm, mls_type, 0, NULL);
 758 }
 759
 760 static void
 761 mls_create_devfs_directory(struct mount *mp, char *dirname, int dirnamelen,
 762     struct devfs_dirent *de, struct label *delabel)
 763 {
 764         struct mac_mls *mm;
 765
 766         mm = SLOT(delabel);
 767         mls_set_effective(mm, MAC_MLS_TYPE_LOW, 0, NULL);
 768 }
 769
 770 static void
 771 mls_create_devfs_symlink(struct ucred *cred, struct mount *mp,
 772     struct devfs_dirent *dd, struct label *ddlabel, struct devfs_dirent *de,
 773     struct label *delabel)
 774 {
 775         struct mac_mls *source, *dest;
 776
 777         source = SLOT(cred->cr_label);
 778         dest = SLOT(delabel);
 779
 780         mls_copy_effective(source, dest);
 781 }
 782
 783 static void
 784 mls_create_mount(struct ucred *cred, struct mount *mp, struct label *mplabel)
 785 {
 786         struct mac_mls *source, *dest;
 787
 788         source = SLOT(cred->cr_label);
 789         dest = SLOT(mplabel);
 790
 791         mls_copy_effective(source, dest);
 792 }
 793
 794 static void
 795 mls_relabel_vnode(struct ucred *cred, struct vnode *vp,
 796     struct label *vplabel, struct label *label)
 797 {
 798         struct mac_mls *source, *dest;
 799
 800         source = SLOT(label);
 801         dest = SLOT(vplabel);
 802
 803         mls_copy(source, dest);
 804 }
 805
 806 static void
 807 mls_update_devfs(struct mount *mp, struct devfs_dirent *de,
 808     struct label *delabel, struct vnode *vp, struct label *vplabel)
 809 {
 810         struct mac_mls *source, *dest;
 811
 812         source = SLOT(vplabel);
 813         dest = SLOT(delabel);
 814
 815         mls_copy_effective(source, dest);
 816 }
 817
 818 static void
 819 mls_associate_vnode_devfs(struct mount *mp, struct label *mplabel,
 820     struct devfs_dirent *de, struct label *delabel, struct vnode *vp,
 821     struct label *vplabel)
 822 {
 823         struct mac_mls *source, *dest;
 824
 825         source = SLOT(delabel);
 826         dest = SLOT(vplabel);
 827
 828         mls_copy_effective(source, dest);
 829 }
 830
 831 static int
 832 mls_associate_vnode_extattr(struct mount *mp, struct label *mplabel,
 833     struct vnode *vp, struct label *vplabel)
 834 {
 835         struct mac_mls temp, *source, *dest;
 836         int buflen, error;
 837
 838         source = SLOT(mplabel);
 839         dest = SLOT(vplabel);
 840
 841         buflen = sizeof(temp);
 842         bzero(&temp, buflen);
 843
 844         error = vn_extattr_get(vp, IO_NODELOCKED, MAC_MLS_EXTATTR_NAMESPACE,
 845             MAC_MLS_EXTATTR_NAME, &buflen, (char *) &temp, curthread);
 846         if (error == ENOATTR || error == EOPNOTSUPP) {
 847                 /* Fall back to the mntlabel. */
 848                 mls_copy_effective(source, dest);
 849                 return (0);
 850         } else if (error)
 851                 return (error);
 852
 853         if (buflen != sizeof(temp)) {
 854                 printf("mls_associate_vnode_extattr: bad size %d\n",
 855                     buflen);
 856                 return (EPERM);
 857         }
 858         if (mls_valid(&temp) != 0) {
 859                 printf("mls_associate_vnode_extattr: invalid\n");
 860                 return (EPERM);
 861         }
 862         if ((temp.mm_flags & MAC_MLS_FLAGS_BOTH) != MAC_MLS_FLAG_EFFECTIVE) {
 863                 printf("mls_associated_vnode_extattr: not effective\n");
 864                 return (EPERM);
 865         }
 866
 867         mls_copy_effective(&temp, dest);
 868         return (0);
 869 }
 870
 871 static void
 872 mls_associate_vnode_singlelabel(struct mount *mp, struct label *mplabel,
 873     struct vnode *vp, struct label *vplabel)
 874 {
 875         struct mac_mls *source, *dest;
 876
 877         source = SLOT(mplabel);
 878         dest = SLOT(vplabel);
 879
 880         mls_copy_effective(source, dest);
 881 }
 882
 883 static int
 884 mls_create_vnode_extattr(struct ucred *cred, struct mount *mp,
 885     struct label *mplabel, struct vnode *dvp, struct label *dvplabel,
 886     struct vnode *vp, struct label *vplabel, struct componentname *cnp)
 887 {
 888         struct mac_mls *source, *dest, temp;
 889         size_t buflen;
 890         int error;
 891
 892         buflen = sizeof(temp);
 893         bzero(&temp, buflen);
 894
 895         source = SLOT(cred->cr_label);
 896         dest = SLOT(vplabel);
 897         mls_copy_effective(source, &temp);
 898
 899         error = vn_extattr_set(vp, IO_NODELOCKED, MAC_MLS_EXTATTR_NAMESPACE,
 900             MAC_MLS_EXTATTR_NAME, buflen, (char *) &temp, curthread);
 901         if (error == 0)
 902                 mls_copy_effective(source, dest);
 903         return (error);
 904 }
 905
 906 static int
 907 mls_setlabel_vnode_extattr(struct ucred *cred, struct vnode *vp,
 908     struct label *vplabel, struct label *intlabel)
 909 {
 910         struct mac_mls *source, temp;
 911         size_t buflen;
 912         int error;
 913
 914         buflen = sizeof(temp);
 915         bzero(&temp, buflen);
 916
 917         source = SLOT(intlabel);
 918         if ((source->mm_flags & MAC_MLS_FLAG_EFFECTIVE) == 0)
 919                 return (0);
 920
 921         mls_copy_effective(source, &temp);
 922
 923         error = vn_extattr_set(vp, IO_NODELOCKED, MAC_MLS_EXTATTR_NAMESPACE,
 924             MAC_MLS_EXTATTR_NAME, buflen, (char *) &temp, curthread);
 925         return (error);
 926 }
 927
 928 /*
 929  * Labeling event operations: IPC object.
 930  */
 931 static void
 932 mls_create_inpcb_from_socket(struct socket *so, struct label *solabel,
 933     struct inpcb *inp, struct label *inplabel)
 934 {
 935         struct mac_mls *source, *dest;
 936
 937         source = SLOT(solabel);
 938         dest = SLOT(inplabel);
 939
 940         mls_copy_effective(source, dest);
 941 }
 942
 943 static void
 944 mls_create_mbuf_from_socket(struct socket *so, struct label *solabel,
 945     struct mbuf *m, struct label *mlabel)
 946 {
 947         struct mac_mls *source, *dest;
 948
 949         source = SLOT(solabel);
 950         dest = SLOT(mlabel);
 951
 952         mls_copy_effective(source, dest);
 953 }
 954
 955 static void
 956 mls_create_socket(struct ucred *cred, struct socket *so,
 957     struct label *solabel)
 958 {
 959         struct mac_mls *source, *dest;
 960
 961         source = SLOT(cred->cr_label);
 962         dest = SLOT(solabel);
 963
 964         mls_copy_effective(source, dest);
 965 }
 966
 967 static void
 968 mls_create_pipe(struct ucred *cred, struct pipepair *pp,
 969     struct label *pplabel)
 970 {
 971         struct mac_mls *source, *dest;
 972
 973         source = SLOT(cred->cr_label);
 974         dest = SLOT(pplabel);
 975
 976         mls_copy_effective(source, dest);
 977 }
 978
 979 static void
 980 mls_create_posix_sem(struct ucred *cred, struct ksem *ks,
 981     struct label *kslabel)
 982 {
 983         struct mac_mls *source, *dest;
 984
 985         source = SLOT(cred->cr_label);
 986         dest = SLOT(kslabel);
 987
 988         mls_copy_effective(source, dest);
 989 }
 990
 991 static void
 992 mls_create_socket_from_socket(struct socket *oldso, struct label *oldsolabel,
 993     struct socket *newso, struct label *newsolabel)
 994 {
 995         struct mac_mls *source, *dest;
 996
 997         source = SLOT(oldsolabel);
 998         dest = SLOT(newsolabel);
 999
1000         mls_copy_effective(source, dest);
1001 }
1002
1003 static void
1004 mls_relabel_socket(struct ucred *cred, struct socket *so,
1005     struct label *solabel, struct label *newlabel)
1006 {
1007         struct mac_mls *source, *dest;
1008
1009         source = SLOT(newlabel);
1010         dest = SLOT(solabel);
1011
1012         mls_copy(source, dest);
1013 }
1014
1015 static void
1016 mls_relabel_pipe(struct ucred *cred, struct pipepair *pp,
1017     struct label *pplabel, struct label *newlabel)
1018 {
1019         struct mac_mls *source, *dest;
1020
1021         source = SLOT(newlabel);
1022         dest = SLOT(pplabel);
1023
1024         mls_copy(source, dest);
1025 }
1026
1027 static void
1028 mls_set_socket_peer_from_mbuf(struct mbuf *m, struct label *mlabel,
1029     struct socket *so, struct label *sopeerlabel)
1030 {
1031         struct mac_mls *source, *dest;
1032
1033         source = SLOT(mlabel);
1034         dest = SLOT(sopeerlabel);
1035
1036         mls_copy_effective(source, dest);
1037 }
1038
1039 /*
1040  * Labeling event operations: System V IPC objects.
1041  */
1042 static void
1043 mls_create_sysv_msgmsg(struct ucred *cred, struct msqid_kernel *msqkptr,
1044     struct label *msqlabel, struct msg *msgptr, struct label *msglabel)
1045 {
1046         struct mac_mls *source, *dest;
1047
1048         /* Ignore the msgq label. */
1049         source = SLOT(cred->cr_label);
1050         dest = SLOT(msglabel);
1051
1052         mls_copy_effective(source, dest);
1053 }
1054
1055 static void
1056 mls_create_sysv_msgqueue(struct ucred *cred, struct msqid_kernel *msqkptr,
1057     struct label *msqlabel)
1058 {
1059         struct mac_mls *source, *dest;
1060
1061         source = SLOT(cred->cr_label);
1062         dest = SLOT(msqlabel);
1063
1064         mls_copy_effective(source, dest);
1065 }
1066
1067 static void
1068 mls_create_sysv_sem(struct ucred *cred, struct semid_kernel *semakptr,
1069     struct label *semalabel)
1070 {
1071         struct mac_mls *source, *dest;
1072
1073         source = SLOT(cred->cr_label);
1074         dest = SLOT(semalabel);
1075
1076         mls_copy_effective(source, dest);
1077 }
1078
1079 static void
1080 mls_create_sysv_shm(struct ucred *cred, struct shmid_kernel *shmsegptr,
1081     struct label *shmlabel)
1082 {
1083         struct mac_mls *source, *dest;
1084
1085         source = SLOT(cred->cr_label);
1086         dest = SLOT(shmlabel);
1087
1088         mls_copy_effective(source, dest);
1089 }
1090
1091 /*
1092  * Labeling event operations: network objects.
1093  */
1094 static void
1095 mls_set_socket_peer_from_socket(struct socket *oldso,
1096     struct label *oldsolabel, struct socket *newso,
1097     struct label *newsopeerlabel)
1098 {
1099         struct mac_mls *source, *dest;
1100
1101         source = SLOT(oldsolabel);
1102         dest = SLOT(newsopeerlabel);
1103
1104         mls_copy_effective(source, dest);
1105 }
1106
1107 static void
1108 mls_create_bpfdesc(struct ucred *cred, struct bpf_d *d, struct label *dlabel)
1109 {
1110         struct mac_mls *source, *dest;
1111
1112         source = SLOT(cred->cr_label);
1113         dest = SLOT(dlabel);
1114
1115         mls_copy_effective(source, dest);
1116 }
1117
1118 static void
1119 mls_create_ifnet(struct ifnet *ifp, struct label *ifplabel)
1120 {
1121         struct mac_mls *dest;
1122         int type;
1123
1124         dest = SLOT(ifplabel);
1125
1126         if (ifp->if_type == IFT_LOOP)
1127                 type = MAC_MLS_TYPE_EQUAL;
1128         else
1129                 type = MAC_MLS_TYPE_LOW;
1130
1131         mls_set_effective(dest, type, 0, NULL);
1132         mls_set_range(dest, type, 0, NULL, type, 0, NULL);
1133 }
1134
1135 static void
1136 mls_create_ipq(struct mbuf *m, struct label *mlabel, struct ipq *q,
1137     struct label *qlabel)
1138 {
1139         struct mac_mls *source, *dest;
1140
1141         source = SLOT(mlabel);
1142         dest = SLOT(qlabel);
1143
1144         mls_copy_effective(source, dest);
1145 }
1146
1147 static void
1148 mls_create_datagram_from_ipq(struct ipq *q, struct label *qlabel,
1149     struct mbuf *m, struct label *mlabel)
1150 {
1151         struct mac_mls *source, *dest;
1152
1153         source = SLOT(qlabel);
1154         dest = SLOT(mlabel);
1155
1156         /* Just use the head, since we require them all to match. */
1157         mls_copy_effective(source, dest);
1158 }
1159
1160 static void
1161 mls_create_fragment(struct mbuf *m, struct label *mlabel,
1162     struct mbuf *frag, struct label *fraglabel)
1163 {
1164         struct mac_mls *source, *dest;
1165
1166         source = SLOT(mlabel);
1167         dest = SLOT(fraglabel);
1168
1169         mls_copy_effective(source, dest);
1170 }
1171
1172 static void
1173 mls_create_mbuf_from_inpcb(struct inpcb *inp, struct label *inplabel,
1174     struct mbuf *m, struct label *mlabel)
1175 {
1176         struct mac_mls *source, *dest;
1177
1178         source = SLOT(inplabel);
1179         dest = SLOT(mlabel);
1180
1181         mls_copy_effective(source, dest);
1182 }
1183
1184 static void
1185 mls_create_mbuf_linklayer(struct ifnet *ifp, struct label *ifplabel,
1186     struct mbuf *m, struct label *mlabel)
1187 {
1188         struct mac_mls *dest;
1189
1190         dest = SLOT(mlabel);
1191
1192         mls_set_effective(dest, MAC_MLS_TYPE_EQUAL, 0, NULL);
1193 }
1194
1195 static void
1196 mls_create_mbuf_from_bpfdesc(struct bpf_d *d, struct label *dlabel,
1197     struct mbuf *m, struct label *mlabel)
1198 {
1199         struct mac_mls *source, *dest;
1200
1201         source = SLOT(dlabel);
1202         dest = SLOT(mlabel);
1203
1204         mls_copy_effective(source, dest);
1205 }
1206
1207 static void
1208 mls_create_mbuf_from_ifnet(struct ifnet *ifp, struct label *ifplabel,
1209     struct mbuf *m, struct label *mlabel)
1210 {
1211         struct mac_mls *source, *dest;
1212
1213         source = SLOT(ifplabel);
1214         dest = SLOT(mlabel);
1215
1216         mls_copy_effective(source, dest);
1217 }
1218
1219 static void
1220 mls_create_mbuf_multicast_encap(struct mbuf *m, struct label *mlabel,
1221     struct ifnet *ifp, struct label *ifplabel, struct mbuf *mnew,
1222     struct label *mnewlabel)
1223 {
1224         struct mac_mls *source, *dest;
1225
1226         source = SLOT(mlabel);
1227         dest = SLOT(mnewlabel);
1228
1229         mls_copy_effective(source, dest);
1230 }
1231
1232 static void
1233 mls_create_mbuf_netlayer(struct mbuf *m, struct label *mlabel,
1234     struct mbuf *mnew, struct label *mnewlabel)
1235 {
1236         struct mac_mls *source, *dest;
1237
1238         source = SLOT(mlabel);
1239         dest = SLOT(mnewlabel);
1240
1241         mls_copy_effective(source, dest);
1242 }
1243
1244 static int
1245 mls_fragment_match(struct mbuf *m, struct label *mlabel, struct ipq *q,
1246     struct label *qlabel)
1247 {
1248         struct mac_mls *a, *b;
1249
1250         a = SLOT(qlabel);
1251         b = SLOT(mlabel);
1252
1253         return (mls_equal_effective(a, b));
1254 }
1255
1256 static void
1257 mls_relabel_ifnet(struct ucred *cred, struct ifnet *ifp,
1258     struct label *ifplabel, struct label *newlabel)
1259 {
1260         struct mac_mls *source, *dest;
1261
1262         source = SLOT(newlabel);
1263         dest = SLOT(ifplabel);
1264
1265         mls_copy(source, dest);
1266 }
1267
1268 static void
1269 mls_update_ipq(struct mbuf *m, struct label *mlabel, struct ipq *q,
1270     struct label *qlabel)
1271 {
1272
1273         /* NOOP: we only accept matching labels, so no need to update */
1274 }
1275
1276 static void
1277 mls_inpcb_sosetlabel(struct socket *so, struct label *solabel,
1278     struct inpcb *inp, struct label *inplabel)
1279 {
1280         struct mac_mls *source, *dest;
1281
1282         source = SLOT(solabel);
1283         dest = SLOT(inplabel);
1284
1285         mls_copy(source, dest);
1286 }
1287
1288 static void
1289 mls_create_mbuf_from_firewall(struct mbuf *m, struct label *mlabel)
1290 {
1291         struct mac_mls *dest;
1292
1293         dest = SLOT(mlabel);
1294
1295         /* XXX: where is the label for the firewall really comming from? */
1296         mls_set_effective(dest, MAC_MLS_TYPE_EQUAL, 0, NULL);
1297 }
1298
1299 static void
1300 mls_init_syncache_from_inpcb(struct label *label, struct inpcb *inp)
1301 {
1302         struct mac_mls *source, *dest;
1303
1304         source = SLOT(inp->inp_label);
1305         dest = SLOT(label);
1306         mls_copy_effective(source, dest);
1307 }
1308
1309 static void
1310 mls_create_mbuf_from_syncache(struct label *sc_label, struct mbuf *m,
1311     struct label *mlabel)
1312 {
1313         struct mac_mls *source, *dest;
1314
1315         source = SLOT(sc_label);
1316         dest = SLOT(mlabel);
1317         mls_copy_effective(source, dest);
1318 }
1319
1320 /*
1321  * Labeling event operations: processes.
1322  */
1323 static void
1324 mls_create_proc0(struct ucred *cred)
1325 {
1326         struct mac_mls *dest;
1327
1328         dest = SLOT(cred->cr_label);
1329
1330         mls_set_effective(dest, MAC_MLS_TYPE_EQUAL, 0, NULL);
1331         mls_set_range(dest, MAC_MLS_TYPE_LOW, 0, NULL, MAC_MLS_TYPE_HIGH, 0,
1332             NULL);
1333 }
1334
1335 static void
1336 mls_create_proc1(struct ucred *cred)
1337 {
1338         struct mac_mls *dest;
1339
1340         dest = SLOT(cred->cr_label);
1341
1342         mls_set_effective(dest, MAC_MLS_TYPE_LOW, 0, NULL);
1343         mls_set_range(dest, MAC_MLS_TYPE_LOW, 0, NULL, MAC_MLS_TYPE_HIGH, 0,
1344             NULL);
1345 }
1346
1347 static void
1348 mls_relabel_cred(struct ucred *cred, struct label *newlabel)
1349 {
1350         struct mac_mls *source, *dest;
1351
1352         source = SLOT(newlabel);
1353         dest = SLOT(cred->cr_label);
1354
1355         mls_copy(source, dest);
1356 }
1357
1358 /*
1359  * Label cleanup/flush operations.
1360  */
1361 static void
1362 mls_cleanup_sysv_msgmsg(struct label *msglabel)
1363 {
1364
1365         bzero(SLOT(msglabel), sizeof(struct mac_mls));
1366 }
1367
1368 static void
1369 mls_cleanup_sysv_msgqueue(struct label *msqlabel)
1370 {
1371
1372         bzero(SLOT(msqlabel), sizeof(struct mac_mls));
1373 }
1374
1375 static void
1376 mls_cleanup_sysv_sem(struct label *semalabel)
1377 {
1378
1379         bzero(SLOT(semalabel), sizeof(struct mac_mls));
1380 }
1381
1382 static void
1383 mls_cleanup_sysv_shm(struct label *shmlabel)
1384 {
1385
1386         bzero(SLOT(shmlabel), sizeof(struct mac_mls));
1387 }
1388
1389 /*
1390  * Access control checks.
1391  */
1392 static int
1393 mls_check_bpfdesc_receive(struct bpf_d *d, struct label *dlabel,
1394      struct ifnet *ifp, struct label *ifplabel)
1395 {
1396         struct mac_mls *a, *b;
1397
1398         if (!mls_enabled)
1399                 return (0);
1400
1401         a = SLOT(dlabel);
1402         b = SLOT(ifplabel);
1403
1404         if (mls_equal_effective(a, b))
1405                 return (0);
1406         return (EACCES);
1407 }
1408
1409 static int
1410 mls_check_cred_relabel(struct ucred *cred, struct label *newlabel)
1411 {
1412         struct mac_mls *subj, *new;
1413         int error;
1414
1415         subj = SLOT(cred->cr_label);
1416         new = SLOT(newlabel);
1417
1418         /*
1419          * If there is an MLS label update for the credential, it may be an
1420          * update of effective, range, or both.
1421          */
1422         error = mls_atmostflags(new, MAC_MLS_FLAGS_BOTH);
1423         if (error)
1424                 return (error);
1425
1426         /*
1427          * If the MLS label is to be changed, authorize as appropriate.
1428          */
1429         if (new->mm_flags & MAC_MLS_FLAGS_BOTH) {
1430                 /*
1431                  * If the change request modifies both the MLS label
1432                  * effective and range, check that the new effective will be
1433                  * in the new range.
1434                  */
1435                 if ((new->mm_flags & MAC_MLS_FLAGS_BOTH) ==
1436                     MAC_MLS_FLAGS_BOTH &&
1437                     !mls_effective_in_range(new, new))
1438                         return (EINVAL);
1439
1440                 /*
1441                  * To change the MLS effective label on a credential, the new
1442                  * effective label must be in the current range.
1443                  */
1444                 if (new->mm_flags & MAC_MLS_FLAG_EFFECTIVE &&
1445                     !mls_effective_in_range(new, subj))
1446                         return (EPERM);
1447
1448                 /*
1449                  * To change the MLS range label on a credential, the new
1450                  * range must be in the current range.
1451                  */
1452                 if (new->mm_flags & MAC_MLS_FLAG_RANGE &&
1453                     !mls_range_in_range(new, subj))
1454                         return (EPERM);
1455
1456                 /*
1457                  * To have EQUAL in any component of the new credential MLS
1458                  * label, the subject must already have EQUAL in their label.
1459                  */
1460                 if (mls_contains_equal(new)) {
1461                         error = mls_subject_privileged(subj);
1462                         if (error)
1463                                 return (error);
1464                 }
1465         }
1466
1467         return (0);
1468 }
1469
1470 static int
1471 mls_check_cred_visible(struct ucred *cr1, struct ucred *cr2)
1472 {
1473         struct mac_mls *subj, *obj;
1474
1475         if (!mls_enabled)
1476                 return (0);
1477
1478         subj = SLOT(cr1->cr_label);
1479         obj = SLOT(cr2->cr_label);
1480
1481         /* XXX: range */
1482         if (!mls_dominate_effective(subj, obj))
1483                 return (ESRCH);
1484
1485         return (0);
1486 }
1487
1488 static int
1489 mls_check_ifnet_relabel(struct ucred *cred, struct ifnet *ifp,
1490     struct label *ifplabel, struct label *newlabel)
1491 {
1492         struct mac_mls *subj, *new;
1493         int error;
1494
1495         subj = SLOT(cred->cr_label);
1496         new = SLOT(newlabel);
1497
1498         /*
1499          * If there is an MLS label update for the interface, it may be an
1500          * update of effective, range, or both.
1501          */
1502         error = mls_atmostflags(new, MAC_MLS_FLAGS_BOTH);
1503         if (error)
1504                 return (error);
1505
1506         /*
1507          * Relabeling network interfaces requires MLS privilege.
1508          */
1509         return (mls_subject_privileged(subj));
1510 }
1511
1512 static int
1513 mls_check_ifnet_transmit(struct ifnet *ifp, struct label *ifplabel,
1514     struct mbuf *m, struct label *mlabel)
1515 {
1516         struct mac_mls *p, *i;
1517
1518         if (!mls_enabled)
1519                 return (0);
1520
1521         p = SLOT(mlabel);
1522         i = SLOT(ifplabel);
1523
1524         return (mls_effective_in_range(p, i) ? 0 : EACCES);
1525 }
1526
1527 static int
1528 mls_check_inpcb_deliver(struct inpcb *inp, struct label *inplabel,
1529     struct mbuf *m, struct label *mlabel)
1530 {
1531         struct mac_mls *p, *i;
1532
1533         if (!mls_enabled)
1534                 return (0);
1535
1536         p = SLOT(mlabel);
1537         i = SLOT(inplabel);
1538
1539         return (mls_equal_effective(p, i) ? 0 : EACCES);
1540 }
1541
1542 static int
1543 mls_check_inpcb_visible(struct ucred *cred, struct inpcb *inp,
1544     struct label *inplabel)
1545 {
1546         struct mac_mls *subj, *obj;
1547
1548         if (!mls_enabled)
1549                 return (0);
1550
1551         subj = SLOT(cred->cr_label);
1552         obj = SLOT(inplabel);
1553
1554         if (!mls_dominate_effective(subj, obj))
1555                 return (ENOENT);
1556
1557         return (0);
1558 }
1559
1560 static int
1561 mls_check_sysv_msgrcv(struct ucred *cred, struct msg *msgptr,
1562     struct label *msglabel)
1563 {
1564         struct mac_mls *subj, *obj;
1565
1566         if (!mls_enabled)
1567                 return (0);
1568
1569         subj = SLOT(cred->cr_label);
1570         obj = SLOT(msglabel);
1571
1572         if (!mls_dominate_effective(subj, obj))
1573                 return (EACCES);
1574
1575         return (0);
1576 }
1577
1578 static int
1579 mls_check_sysv_msgrmid(struct ucred *cred, struct msg *msgptr,
1580     struct label *msglabel)
1581 {
1582         struct mac_mls *subj, *obj;
1583
1584         if (!mls_enabled)
1585                 return (0);
1586
1587         subj = SLOT(cred->cr_label);
1588         obj = SLOT(msglabel);
1589
1590         if (!mls_dominate_effective(obj, subj))
1591                 return (EACCES);
1592
1593         return (0);
1594 }
1595
1596 static int
1597 mls_check_sysv_msqget(struct ucred *cred, struct msqid_kernel *msqkptr,
1598     struct label *msqklabel)
1599 {
1600         struct mac_mls *subj, *obj;
1601
1602         if (!mls_enabled)
1603                 return (0);
1604
1605         subj = SLOT(cred->cr_label);
1606         obj = SLOT(msqklabel);
1607
1608         if (!mls_dominate_effective(subj, obj))
1609                 return (EACCES);
1610
1611         return (0);
1612 }
1613
1614 static int
1615 mls_check_sysv_msqsnd(struct ucred *cred, struct msqid_kernel *msqkptr,
1616     struct label *msqklabel)
1617 {
1618         struct mac_mls *subj, *obj;
1619
1620         if (!mls_enabled)
1621                 return (0);
1622
1623         subj = SLOT(cred->cr_label);
1624         obj = SLOT(msqklabel);
1625
1626         if (!mls_dominate_effective(obj, subj))
1627                 return (EACCES);
1628
1629         return (0);
1630 }
1631
1632 static int
1633 mls_check_sysv_msqrcv(struct ucred *cred, struct msqid_kernel *msqkptr,
1634     struct label *msqklabel)
1635 {
1636         struct mac_mls *subj, *obj;
1637
1638         if (!mls_enabled)
1639                 return (0);
1640
1641         subj = SLOT(cred->cr_label);
1642         obj = SLOT(msqklabel);
1643
1644         if (!mls_dominate_effective(subj, obj))
1645                 return (EACCES);
1646
1647         return (0);
1648 }
1649
1650 static int
1651 mls_check_sysv_msqctl(struct ucred *cred, struct msqid_kernel *msqkptr,
1652     struct label *msqklabel, int cmd)
1653 {
1654         struct mac_mls *subj, *obj;
1655
1656         if (!mls_enabled)
1657                 return (0);
1658
1659         subj = SLOT(cred->cr_label);
1660         obj = SLOT(msqklabel);
1661
1662         switch(cmd) {
1663         case IPC_RMID:
1664         case IPC_SET:
1665                 if (!mls_dominate_effective(obj, subj))
1666                         return (EACCES);
1667                 break;
1668
1669         case IPC_STAT:
1670                 if (!mls_dominate_effective(subj, obj))
1671                         return (EACCES);
1672                 break;
1673
1674         default:
1675                 return (EACCES);
1676         }
1677
1678         return (0);
1679 }
1680
1681 static int
1682 mls_check_sysv_semctl(struct ucred *cred, struct semid_kernel *semakptr,
1683     struct label *semaklabel, int cmd)
1684 {
1685         struct mac_mls *subj, *obj;
1686
1687         if (!mls_enabled)
1688                 return (0);
1689
1690         subj = SLOT(cred->cr_label);
1691         obj = SLOT(semaklabel);
1692
1693         switch(cmd) {
1694         case IPC_RMID:
1695         case IPC_SET:
1696         case SETVAL:
1697         case SETALL:
1698                 if (!mls_dominate_effective(obj, subj))
1699                         return (EACCES);
1700                 break;
1701
1702         case IPC_STAT:
1703         case GETVAL:
1704         case GETPID:
1705         case GETNCNT:
1706         case GETZCNT:
1707         case GETALL:
1708                 if (!mls_dominate_effective(subj, obj))
1709                         return (EACCES);
1710                 break;
1711
1712         default:
1713                 return (EACCES);
1714         }
1715
1716         return (0);
1717 }
1718
1719 static int
1720 mls_check_sysv_semget(struct ucred *cred, struct semid_kernel *semakptr,
1721     struct label *semaklabel)
1722 {
1723         struct mac_mls *subj, *obj;
1724
1725         if (!mls_enabled)
1726                 return (0);
1727
1728         subj = SLOT(cred->cr_label);
1729         obj = SLOT(semaklabel);
1730
1731         if (!mls_dominate_effective(subj, obj))
1732                 return (EACCES);
1733
1734         return (0);
1735 }
1736
1737 static int
1738 mls_check_sysv_semop(struct ucred *cred, struct semid_kernel *semakptr,
1739     struct label *semaklabel, size_t accesstype)
1740 {
1741         struct mac_mls *subj, *obj;
1742
1743         if (!mls_enabled)
1744                 return (0);
1745
1746         subj = SLOT(cred->cr_label);
1747         obj = SLOT(semaklabel);
1748
1749         if (accesstype & SEM_R)
1750                 if (!mls_dominate_effective(subj, obj))
1751                         return (EACCES);
1752
1753         if (accesstype & SEM_A)
1754                 if (!mls_dominate_effective(obj, subj))
1755                         return (EACCES);
1756
1757         return (0);
1758 }
1759
1760 static int
1761 mls_check_sysv_shmat(struct ucred *cred, struct shmid_kernel *shmsegptr,
1762     struct label *shmseglabel, int shmflg)
1763 {
1764         struct mac_mls *subj, *obj;
1765
1766         if (!mls_enabled)
1767                 return (0);
1768
1769         subj = SLOT(cred->cr_label);
1770         obj = SLOT(shmseglabel);
1771
1772         if (!mls_dominate_effective(subj, obj))
1773                 return (EACCES);
1774         if ((shmflg & SHM_RDONLY) == 0)
1775                 if (!mls_dominate_effective(obj, subj))
1776                         return (EACCES);
1777
1778         return (0);
1779 }
1780
1781 static int
1782 mls_check_sysv_shmctl(struct ucred *cred, struct shmid_kernel *shmsegptr,
1783     struct label *shmseglabel, int cmd)
1784 {
1785         struct mac_mls *subj, *obj;
1786
1787         if (!mls_enabled)
1788                 return (0);
1789
1790         subj = SLOT(cred->cr_label);
1791         obj = SLOT(shmseglabel);
1792
1793         switch(cmd) {
1794         case IPC_RMID:
1795         case IPC_SET:
1796                 if (!mls_dominate_effective(obj, subj))
1797                         return (EACCES);
1798                 break;
1799
1800         case IPC_STAT:
1801         case SHM_STAT:
1802                 if (!mls_dominate_effective(subj, obj))
1803                         return (EACCES);
1804                 break;
1805
1806         default:
1807                 return (EACCES);
1808         }
1809
1810         return (0);
1811 }
1812
1813 static int
1814 mls_check_sysv_shmget(struct ucred *cred, struct shmid_kernel *shmsegptr,
1815     struct label *shmseglabel, int shmflg)
1816 {
1817         struct mac_mls *subj, *obj;
1818
1819         if (!mls_enabled)
1820                 return (0);
1821
1822         subj = SLOT(cred->cr_label);
1823         obj = SLOT(shmseglabel);
1824
1825         if (!mls_dominate_effective(obj, subj))
1826                 return (EACCES);
1827
1828         return (0);
1829 }
1830
1831 static int
1832 mls_check_mount_stat(struct ucred *cred, struct mount *mp,
1833     struct label *mntlabel)
1834 {
1835         struct mac_mls *subj, *obj;
1836
1837         if (!mls_enabled)
1838                 return (0);
1839
1840         subj = SLOT(cred->cr_label);
1841         obj = SLOT(mntlabel);
1842
1843         if (!mls_dominate_effective(subj, obj))
1844                 return (EACCES);
1845
1846         return (0);
1847 }
1848
1849 static int
1850 mls_check_pipe_ioctl(struct ucred *cred, struct pipepair *pp,
1851     struct label *pplabel, unsigned long cmd, void /* caddr_t */ *data)
1852 {
1853
1854         if(!mls_enabled)
1855                 return (0);
1856
1857         /* XXX: This will be implemented soon... */
1858
1859         return (0);
1860 }
1861
1862 static int
1863 mls_check_pipe_poll(struct ucred *cred, struct pipepair *pp,
1864     struct label *pplabel)
1865 {
1866         struct mac_mls *subj, *obj;
1867
1868         if (!mls_enabled)
1869                 return (0);
1870
1871         subj = SLOT(cred->cr_label);
1872         obj = SLOT(pplabel);
1873
1874         if (!mls_dominate_effective(subj, obj))
1875                 return (EACCES);
1876
1877         return (0);
1878 }
1879
1880 static int
1881 mls_check_pipe_read(struct ucred *cred, struct pipepair *pp,
1882     struct label *pplabel)
1883 {
1884         struct mac_mls *subj, *obj;
1885
1886         if (!mls_enabled)
1887                 return (0);
1888
1889         subj = SLOT(cred->cr_label);
1890         obj = SLOT(pplabel);
1891
1892         if (!mls_dominate_effective(subj, obj))
1893                 return (EACCES);
1894
1895         return (0);
1896 }
1897
1898 static int
1899 mls_check_pipe_relabel(struct ucred *cred, struct pipepair *pp,
1900     struct label *pplabel, struct label *newlabel)
1901 {
1902         struct mac_mls *subj, *obj, *new;
1903         int error;
1904
1905         new = SLOT(newlabel);
1906         subj = SLOT(cred->cr_label);
1907         obj = SLOT(pplabel);
1908
1909         /*
1910          * If there is an MLS label update for a pipe, it must be a effective
1911          * update.
1912          */
1913         error = mls_atmostflags(new, MAC_MLS_FLAG_EFFECTIVE);
1914         if (error)
1915                 return (error);
1916
1917         /*
1918          * To perform a relabel of a pipe (MLS label or not), MLS must
1919          * authorize the relabel.
1920          */
1921         if (!mls_effective_in_range(obj, subj))
1922                 return (EPERM);
1923
1924         /*
1925          * If the MLS label is to be changed, authorize as appropriate.
1926          */
1927         if (new->mm_flags & MAC_MLS_FLAG_EFFECTIVE) {
1928                 /*
1929                  * To change the MLS label on a pipe, the new pipe label must
1930                  * be in the subject range.
1931                  */
1932                 if (!mls_effective_in_range(new, subj))
1933                         return (EPERM);
1934
1935                 /*
1936                  * To change the MLS label on a pipe to be EQUAL, the subject
1937                  * must have appropriate privilege.
1938                  */
1939                 if (mls_contains_equal(new)) {
1940                         error = mls_subject_privileged(subj);
1941                         if (error)
1942                                 return (error);
1943                 }
1944         }
1945
1946         return (0);
1947 }
1948
1949 static int
1950 mls_check_pipe_stat(struct ucred *cred, struct pipepair *pp,
1951     struct label *pplabel)
1952 {
1953         struct mac_mls *subj, *obj;
1954
1955         if (!mls_enabled)
1956                 return (0);
1957
1958         subj = SLOT(cred->cr_label);
1959         obj = SLOT(pplabel);
1960
1961         if (!mls_dominate_effective(subj, obj))
1962                 return (EACCES);
1963
1964         return (0);
1965 }
1966
1967 static int
1968 mls_check_pipe_write(struct ucred *cred, struct pipepair *pp,
1969     struct label *pplabel)
1970 {
1971         struct mac_mls *subj, *obj;
1972
1973         if (!mls_enabled)
1974                 return (0);
1975
1976         subj = SLOT(cred->cr_label);
1977         obj = SLOT(pplabel);
1978
1979         if (!mls_dominate_effective(obj, subj))
1980                 return (EACCES);
1981
1982         return (0);
1983 }
1984
1985 static int
1986 mls_check_posix_sem_write(struct ucred *cred, struct ksem *ks,
1987     struct label *kslabel)
1988 {
1989         struct mac_mls *subj, *obj;
1990
1991         if (!mls_enabled)
1992                 return (0);
1993
1994         subj = SLOT(cred->cr_label);
1995         obj = SLOT(kslabel);
1996
1997         if (!mls_dominate_effective(obj, subj))
1998                 return (EACCES);
1999
2000         return (0);
2001 }
2002
2003 static int
2004 mls_check_posix_sem_rdonly(struct ucred *cred, struct ksem *ks,
2005     struct label *kslabel)
2006 {
2007         struct mac_mls *subj, *obj;
2008
2009         if (!mls_enabled)
2010                 return (0);
2011
2012         subj = SLOT(cred->cr_label);
2013         obj = SLOT(kslabel);
2014
2015         if (!mls_dominate_effective(subj, obj))
2016                 return (EACCES);
2017
2018         return (0);
2019 }
2020
2021 static int
2022 mls_check_proc_debug(struct ucred *cred, struct proc *p)
2023 {
2024         struct mac_mls *subj, *obj;
2025
2026         if (!mls_enabled)
2027                 return (0);
2028
2029         subj = SLOT(cred->cr_label);
2030         obj = SLOT(p->p_ucred->cr_label);
2031
2032         /* XXX: range checks */
2033         if (!mls_dominate_effective(subj, obj))
2034                 return (ESRCH);
2035         if (!mls_dominate_effective(obj, subj))
2036                 return (EACCES);
2037
2038         return (0);
2039 }
2040
2041 static int
2042 mls_check_proc_sched(struct ucred *cred, struct proc *p)
2043 {
2044         struct mac_mls *subj, *obj;
2045
2046         if (!mls_enabled)
2047                 return (0);
2048
2049         subj = SLOT(cred->cr_label);
2050         obj = SLOT(p->p_ucred->cr_label);
2051
2052         /* XXX: range checks */
2053         if (!mls_dominate_effective(subj, obj))
2054                 return (ESRCH);
2055         if (!mls_dominate_effective(obj, subj))
2056                 return (EACCES);
2057
2058         return (0);
2059 }
2060
2061 static int
2062 mls_check_proc_signal(struct ucred *cred, struct proc *p, int signum)
2063 {
2064         struct mac_mls *subj, *obj;
2065
2066         if (!mls_enabled)
2067                 return (0);
2068
2069         subj = SLOT(cred->cr_label);
2070         obj = SLOT(p->p_ucred->cr_label);
2071
2072         /* XXX: range checks */
2073         if (!mls_dominate_effective(subj, obj))
2074                 return (ESRCH);
2075         if (!mls_dominate_effective(obj, subj))
2076                 return (EACCES);
2077
2078         return (0);
2079 }
2080
2081 static int
2082 mls_check_socket_deliver(struct socket *so, struct label *solabel,
2083     struct mbuf *m, struct label *mlabel)
2084 {
2085         struct mac_mls *p, *s;
2086
2087         if (!mls_enabled)
2088                 return (0);
2089
2090         p = SLOT(mlabel);
2091         s = SLOT(solabel);
2092
2093         return (mls_equal_effective(p, s) ? 0 : EACCES);
2094 }
2095
2096 static int
2097 mls_check_socket_relabel(struct ucred *cred, struct socket *so,
2098     struct label *solabel, struct label *newlabel)
2099 {
2100         struct mac_mls *subj, *obj, *new;
2101         int error;
2102
2103         new = SLOT(newlabel);
2104         subj = SLOT(cred->cr_label);
2105         obj = SLOT(solabel);
2106
2107         /*
2108          * If there is an MLS label update for the socket, it may be an
2109          * update of effective.
2110          */
2111         error = mls_atmostflags(new, MAC_MLS_FLAG_EFFECTIVE);
2112         if (error)
2113                 return (error);
2114
2115         /*
2116          * To relabel a socket, the old socket effective must be in the
2117          * subject range.
2118          */
2119         if (!mls_effective_in_range(obj, subj))
2120                 return (EPERM);
2121
2122         /*
2123          * If the MLS label is to be changed, authorize as appropriate.
2124          */
2125         if (new->mm_flags & MAC_MLS_FLAG_EFFECTIVE) {
2126                 /*
2127                  * To relabel a socket, the new socket effective must be in
2128                  * the subject range.
2129                  */
2130                 if (!mls_effective_in_range(new, subj))
2131                         return (EPERM);
2132
2133                 /*
2134                  * To change the MLS label on the socket to contain EQUAL,
2135                  * the subject must have appropriate privilege.
2136                  */
2137                 if (mls_contains_equal(new)) {
2138                         error = mls_subject_privileged(subj);
2139                         if (error)
2140                                 return (error);
2141                 }
2142         }
2143
2144         return (0);
2145 }
2146
2147 static int
2148 mls_check_socket_visible(struct ucred *cred, struct socket *so,
2149     struct label *solabel)
2150 {
2151         struct mac_mls *subj, *obj;
2152
2153         if (!mls_enabled)
2154                 return (0);
2155
2156         subj = SLOT(cred->cr_label);
2157         obj = SLOT(solabel);
2158
2159         if (!mls_dominate_effective(subj, obj))
2160                 return (ENOENT);
2161
2162         return (0);
2163 }
2164
2165 static int
2166 mls_check_system_acct(struct ucred *cred, struct vnode *vp,
2167     struct label *vplabel)
2168 {
2169         struct mac_mls *subj, *obj;
2170
2171         if (!mls_enabled)
2172                 return (0);
2173
2174         subj = SLOT(cred->cr_label);
2175         obj = SLOT(vplabel);
2176
2177         if (!mls_dominate_effective(obj, subj) ||
2178             !mls_dominate_effective(subj, obj))
2179                 return (EACCES);
2180
2181         return (0);
2182 }
2183
2184 static int
2185 mls_check_system_auditctl(struct ucred *cred, struct vnode *vp,
2186     struct label *vplabel)
2187 {
2188         struct mac_mls *subj, *obj;
2189
2190         if (!mls_enabled)
2191                 return (0);
2192
2193         subj = SLOT(cred->cr_label);
2194         obj = SLOT(vplabel);
2195
2196         if (!mls_dominate_effective(obj, subj) ||
2197             !mls_dominate_effective(subj, obj))
2198                 return (EACCES);
2199
2200         return (0);
2201 }
2202
2203 static int
2204 mls_check_system_swapon(struct ucred *cred, struct vnode *vp,
2205     struct label *vplabel)
2206 {
2207         struct mac_mls *subj, *obj;
2208
2209         if (!mls_enabled)
2210                 return (0);
2211
2212         subj = SLOT(cred->cr_label);
2213         obj = SLOT(vplabel);
2214
2215         if (!mls_dominate_effective(obj, subj) ||
2216             !mls_dominate_effective(subj, obj))
2217                 return (EACCES);
2218
2219         return (0);
2220 }
2221
2222 static int
2223 mls_check_vnode_chdir(struct ucred *cred, struct vnode *dvp,
2224     struct label *dvplabel)
2225 {
2226         struct mac_mls *subj, *obj;
2227
2228         if (!mls_enabled)
2229                 return (0);
2230
2231         subj = SLOT(cred->cr_label);
2232         obj = SLOT(dvplabel);
2233
2234         if (!mls_dominate_effective(subj, obj))
2235                 return (EACCES);
2236
2237         return (0);
2238 }
2239
2240 static int
2241 mls_check_vnode_chroot(struct ucred *cred, struct vnode *dvp,
2242     struct label *dvplabel)
2243 {
2244         struct mac_mls *subj, *obj;
2245
2246         if (!mls_enabled)
2247                 return (0);
2248
2249         subj = SLOT(cred->cr_label);
2250         obj = SLOT(dvplabel);
2251
2252         if (!mls_dominate_effective(subj, obj))
2253                 return (EACCES);
2254
2255         return (0);
2256 }
2257
2258 static int
2259 mls_check_vnode_create(struct ucred *cred, struct vnode *dvp,
2260     struct label *dvplabel, struct componentname *cnp, struct vattr *vap)
2261 {
2262         struct mac_mls *subj, *obj;
2263
2264         if (!mls_enabled)
2265                 return (0);
2266
2267         subj = SLOT(cred->cr_label);
2268         obj = SLOT(dvplabel);
2269
2270         if (!mls_dominate_effective(obj, subj))
2271                 return (EACCES);
2272
2273         return (0);
2274 }
2275
2276 static int
2277 mls_check_vnode_deleteacl(struct ucred *cred, struct vnode *vp,
2278     struct label *vplabel, acl_type_t type)
2279 {
2280         struct mac_mls *subj, *obj;
2281
2282         if (!mls_enabled)
2283                 return (0);
2284
2285         subj = SLOT(cred->cr_label);
2286         obj = SLOT(vplabel);
2287
2288         if (!mls_dominate_effective(obj, subj))
2289                 return (EACCES);
2290
2291         return (0);
2292 }
2293
2294 static int
2295 mls_check_vnode_deleteextattr(struct ucred *cred, struct vnode *vp,
2296     struct label *vplabel, int attrnamespace, const char *name)
2297 {
2298         struct mac_mls *subj, *obj;
2299
2300         if (!mls_enabled)
2301                 return (0);
2302
2303         subj = SLOT(cred->cr_label);
2304         obj = SLOT(vplabel);
2305
2306         if (!mls_dominate_effective(obj, subj))
2307                 return (EACCES);
2308
2309         return (0);
2310 }
2311
2312 static int
2313 mls_check_vnode_exec(struct ucred *cred, struct vnode *vp,
2314     struct label *vplabel, struct image_params *imgp,
2315     struct label *execlabel)
2316 {
2317         struct mac_mls *subj, *obj, *exec;
2318         int error;
2319
2320         if (execlabel != NULL) {
2321                 /*
2322                  * We currently don't permit labels to be changed at
2323                  * exec-time as part of MLS, so disallow non-NULL MLS label
2324                  * elements in the execlabel.
2325                  */
2326                 exec = SLOT(execlabel);
2327                 error = mls_atmostflags(exec, 0);
2328                 if (error)
2329                         return (error);
2330         }
2331
2332         if (!mls_enabled)
2333                 return (0);
2334
2335         subj = SLOT(cred->cr_label);
2336         obj = SLOT(vplabel);
2337
2338         if (!mls_dominate_effective(subj, obj))
2339                 return (EACCES);
2340
2341         return (0);
2342 }
2343
2344 static int
2345 mls_check_vnode_getacl(struct ucred *cred, struct vnode *vp,
2346     struct label *vplabel, acl_type_t type)
2347 {
2348         struct mac_mls *subj, *obj;
2349
2350         if (!mls_enabled)
2351                 return (0);
2352
2353         subj = SLOT(cred->cr_label);
2354         obj = SLOT(vplabel);
2355
2356         if (!mls_dominate_effective(subj, obj))
2357                 return (EACCES);
2358
2359         return (0);
2360 }
2361
2362 static int
2363 mls_check_vnode_getextattr(struct ucred *cred, struct vnode *vp,
2364     struct label *vplabel, int attrnamespace, const char *name,
2365     struct uio *uio)
2366 {
2367         struct mac_mls *subj, *obj;
2368
2369         if (!mls_enabled)
2370                 return (0);
2371
2372         subj = SLOT(cred->cr_label);
2373         obj = SLOT(vplabel);
2374
2375         if (!mls_dominate_effective(subj, obj))
2376                 return (EACCES);
2377
2378         return (0);
2379 }
2380
2381 static int
2382 mls_check_vnode_link(struct ucred *cred, struct vnode *dvp,
2383     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2384     struct componentname *cnp)
2385 {
2386         struct mac_mls *subj, *obj;
2387
2388         if (!mls_enabled)
2389                 return (0);
2390
2391         subj = SLOT(cred->cr_label);
2392         obj = SLOT(dvplabel);
2393
2394         if (!mls_dominate_effective(obj, subj))
2395                 return (EACCES);
2396
2397         obj = SLOT(vplabel);
2398         if (!mls_dominate_effective(obj, subj))
2399                 return (EACCES);
2400
2401         return (0);
2402 }
2403
2404 static int
2405 mls_check_vnode_listextattr(struct ucred *cred, struct vnode *vp,
2406     struct label *vplabel, int attrnamespace)
2407 {
2408
2409         struct mac_mls *subj, *obj;
2410
2411         if (!mls_enabled)
2412                 return (0);
2413
2414         subj = SLOT(cred->cr_label);
2415         obj = SLOT(vplabel);
2416
2417         if (!mls_dominate_effective(subj, obj))
2418                 return (EACCES);
2419
2420         return (0);
2421 }
2422
2423 static int
2424 mls_check_vnode_lookup(struct ucred *cred, struct vnode *dvp,
2425     struct label *dvplabel, struct componentname *cnp)
2426 {
2427         struct mac_mls *subj, *obj;
2428
2429         if (!mls_enabled)
2430                 return (0);
2431
2432         subj = SLOT(cred->cr_label);
2433         obj = SLOT(dvplabel);
2434
2435         if (!mls_dominate_effective(subj, obj))
2436                 return (EACCES);
2437
2438         return (0);
2439 }
2440
2441 static int
2442 mls_check_vnode_mmap(struct ucred *cred, struct vnode *vp,
2443     struct label *vplabel, int prot, int flags)
2444 {
2445         struct mac_mls *subj, *obj;
2446
2447         /*
2448          * Rely on the use of open()-time protections to handle
2449          * non-revocation cases.
2450          */
2451         if (!mls_enabled || !revocation_enabled)
2452                 return (0);
2453
2454         subj = SLOT(cred->cr_label);
2455         obj = SLOT(vplabel);
2456
2457         if (prot & (VM_PROT_READ | VM_PROT_EXECUTE)) {
2458                 if (!mls_dominate_effective(subj, obj))
2459                         return (EACCES);
2460         }
2461         if (((prot & VM_PROT_WRITE) != 0) && ((flags & MAP_SHARED) != 0)) {
2462                 if (!mls_dominate_effective(obj, subj))
2463                         return (EACCES);
2464         }
2465
2466         return (0);
2467 }
2468
2469 static int
2470 mls_check_vnode_open(struct ucred *cred, struct vnode *vp,
2471     struct label *vplabel, int acc_mode)
2472 {
2473         struct mac_mls *subj, *obj;
2474
2475         if (!mls_enabled)
2476                 return (0);
2477
2478         subj = SLOT(cred->cr_label);
2479         obj = SLOT(vplabel);
2480
2481         /* XXX privilege override for admin? */
2482         if (acc_mode & (VREAD | VEXEC | VSTAT)) {
2483                 if (!mls_dominate_effective(subj, obj))
2484                         return (EACCES);
2485         }
2486         if (acc_mode & (VWRITE | VAPPEND | VADMIN)) {
2487                 if (!mls_dominate_effective(obj, subj))
2488                         return (EACCES);
2489         }
2490
2491         return (0);
2492 }
2493
2494 static int
2495 mls_check_vnode_poll(struct ucred *active_cred, struct ucred *file_cred,
2496     struct vnode *vp, struct label *vplabel)
2497 {
2498         struct mac_mls *subj, *obj;
2499
2500         if (!mls_enabled || !revocation_enabled)
2501                 return (0);
2502
2503         subj = SLOT(active_cred->cr_label);
2504         obj = SLOT(vplabel);
2505
2506         if (!mls_dominate_effective(subj, obj))
2507                 return (EACCES);
2508
2509         return (0);
2510 }
2511
2512 static int
2513 mls_check_vnode_read(struct ucred *active_cred, struct ucred *file_cred,
2514     struct vnode *vp, struct label *vplabel)
2515 {
2516         struct mac_mls *subj, *obj;
2517
2518         if (!mls_enabled || !revocation_enabled)
2519                 return (0);
2520
2521         subj = SLOT(active_cred->cr_label);
2522         obj = SLOT(vplabel);
2523
2524         if (!mls_dominate_effective(subj, obj))
2525                 return (EACCES);
2526
2527         return (0);
2528 }
2529
2530 static int
2531 mls_check_vnode_readdir(struct ucred *cred, struct vnode *dvp,
2532     struct label *dvplabel)
2533 {
2534         struct mac_mls *subj, *obj;
2535
2536         if (!mls_enabled)
2537                 return (0);
2538
2539         subj = SLOT(cred->cr_label);
2540         obj = SLOT(dvplabel);
2541
2542         if (!mls_dominate_effective(subj, obj))
2543                 return (EACCES);
2544
2545         return (0);
2546 }
2547
2548 static int
2549 mls_check_vnode_readlink(struct ucred *cred, struct vnode *vp,
2550     struct label *vplabel)
2551 {
2552         struct mac_mls *subj, *obj;
2553
2554         if (!mls_enabled)
2555                 return (0);
2556
2557         subj = SLOT(cred->cr_label);
2558         obj = SLOT(vplabel);
2559
2560         if (!mls_dominate_effective(subj, obj))
2561                 return (EACCES);
2562
2563         return (0);
2564 }
2565
2566 static int
2567 mls_check_vnode_relabel(struct ucred *cred, struct vnode *vp,
2568     struct label *vplabel, struct label *newlabel)
2569 {
2570         struct mac_mls *old, *new, *subj;
2571         int error;
2572
2573         old = SLOT(vplabel);
2574         new = SLOT(newlabel);
2575         subj = SLOT(cred->cr_label);
2576
2577         /*
2578          * If there is an MLS label update for the vnode, it must be a
2579          * effective label.
2580          */
2581         error = mls_atmostflags(new, MAC_MLS_FLAG_EFFECTIVE);
2582         if (error)
2583                 return (error);
2584
2585         /*
2586          * To perform a relabel of the vnode (MLS label or not), MLS must
2587          * authorize the relabel.
2588          */
2589         if (!mls_effective_in_range(old, subj))
2590                 return (EPERM);
2591
2592         /*
2593          * If the MLS label is to be changed, authorize as appropriate.
2594          */
2595         if (new->mm_flags & MAC_MLS_FLAG_EFFECTIVE) {
2596                 /*
2597                  * To change the MLS label on a vnode, the new vnode label
2598                  * must be in the subject range.
2599                  */
2600                 if (!mls_effective_in_range(new, subj))
2601                         return (EPERM);
2602
2603                 /*
2604                  * To change the MLS label on the vnode to be EQUAL, the
2605                  * subject must have appropriate privilege.
2606                  */
2607                 if (mls_contains_equal(new)) {
2608                         error = mls_subject_privileged(subj);
2609                         if (error)
2610                                 return (error);
2611                 }
2612         }
2613
2614         return (0);
2615 }
2616
2617 static int
2618 mls_check_vnode_rename_from(struct ucred *cred, struct vnode *dvp,
2619     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2620     struct componentname *cnp)
2621 {
2622         struct mac_mls *subj, *obj;
2623
2624         if (!mls_enabled)
2625                 return (0);
2626
2627         subj = SLOT(cred->cr_label);
2628         obj = SLOT(dvplabel);
2629
2630         if (!mls_dominate_effective(obj, subj))
2631                 return (EACCES);
2632
2633         obj = SLOT(vplabel);
2634
2635         if (!mls_dominate_effective(obj, subj))
2636                 return (EACCES);
2637
2638         return (0);
2639 }
2640
2641 static int
2642 mls_check_vnode_rename_to(struct ucred *cred, struct vnode *dvp,
2643     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2644     int samedir, struct componentname *cnp)
2645 {
2646         struct mac_mls *subj, *obj;
2647
2648         if (!mls_enabled)
2649                 return (0);
2650
2651         subj = SLOT(cred->cr_label);
2652         obj = SLOT(dvplabel);
2653
2654         if (!mls_dominate_effective(obj, subj))
2655                 return (EACCES);
2656
2657         if (vp != NULL) {
2658                 obj = SLOT(vplabel);
2659
2660                 if (!mls_dominate_effective(obj, subj))
2661                         return (EACCES);
2662         }
2663
2664         return (0);
2665 }
2666
2667 static int
2668 mls_check_vnode_revoke(struct ucred *cred, struct vnode *vp,
2669     struct label *vplabel)
2670 {
2671         struct mac_mls *subj, *obj;
2672
2673         if (!mls_enabled)
2674                 return (0);
2675
2676         subj = SLOT(cred->cr_label);
2677         obj = SLOT(vplabel);
2678
2679         if (!mls_dominate_effective(obj, subj))
2680                 return (EACCES);
2681
2682         return (0);
2683 }
2684
2685 static int
2686 mls_check_vnode_setacl(struct ucred *cred, struct vnode *vp,
2687     struct label *vplabel, acl_type_t type, struct acl *acl)
2688 {
2689         struct mac_mls *subj, *obj;
2690
2691         if (!mls_enabled)
2692                 return (0);
2693
2694         subj = SLOT(cred->cr_label);
2695         obj = SLOT(vplabel);
2696
2697         if (!mls_dominate_effective(obj, subj))
2698                 return (EACCES);
2699
2700         return (0);
2701 }
2702
2703 static int
2704 mls_check_vnode_setextattr(struct ucred *cred, struct vnode *vp,
2705     struct label *vplabel, int attrnamespace, const char *name,
2706     struct uio *uio)
2707 {
2708         struct mac_mls *subj, *obj;
2709
2710         if (!mls_enabled)
2711                 return (0);
2712
2713         subj = SLOT(cred->cr_label);
2714         obj = SLOT(vplabel);
2715
2716         if (!mls_dominate_effective(obj, subj))
2717                 return (EACCES);
2718
2719         /* XXX: protect the MAC EA in a special way? */
2720
2721         return (0);
2722 }
2723
2724 static int
2725 mls_check_vnode_setflags(struct ucred *cred, struct vnode *vp,
2726     struct label *vplabel, u_long flags)
2727 {
2728         struct mac_mls *subj, *obj;
2729
2730         if (!mls_enabled)
2731                 return (0);
2732
2733         subj = SLOT(cred->cr_label);
2734         obj = SLOT(vplabel);
2735
2736         if (!mls_dominate_effective(obj, subj))
2737                 return (EACCES);
2738
2739         return (0);
2740 }
2741
2742 static int
2743 mls_check_vnode_setmode(struct ucred *cred, struct vnode *vp,
2744     struct label *vplabel, mode_t mode)
2745 {
2746         struct mac_mls *subj, *obj;
2747
2748         if (!mls_enabled)
2749                 return (0);
2750
2751         subj = SLOT(cred->cr_label);
2752         obj = SLOT(vplabel);
2753
2754         if (!mls_dominate_effective(obj, subj))
2755                 return (EACCES);
2756
2757         return (0);
2758 }
2759
2760 static int
2761 mls_check_vnode_setowner(struct ucred *cred, struct vnode *vp,
2762     struct label *vplabel, uid_t uid, gid_t gid)
2763 {
2764         struct mac_mls *subj, *obj;
2765
2766         if (!mls_enabled)
2767                 return (0);
2768
2769         subj = SLOT(cred->cr_label);
2770         obj = SLOT(vplabel);
2771
2772         if (!mls_dominate_effective(obj, subj))
2773                 return (EACCES);
2774
2775         return (0);
2776 }
2777
2778 static int
2779 mls_check_vnode_setutimes(struct ucred *cred, struct vnode *vp,
2780     struct label *vplabel, struct timespec atime, struct timespec mtime)
2781 {
2782         struct mac_mls *subj, *obj;
2783
2784         if (!mls_enabled)
2785                 return (0);
2786
2787         subj = SLOT(cred->cr_label);
2788         obj = SLOT(vplabel);
2789
2790         if (!mls_dominate_effective(obj, subj))
2791                 return (EACCES);
2792
2793         return (0);
2794 }
2795
2796 static int
2797 mls_check_vnode_stat(struct ucred *active_cred, struct ucred *file_cred,
2798     struct vnode *vp, struct label *vplabel)
2799 {
2800         struct mac_mls *subj, *obj;
2801
2802         if (!mls_enabled)
2803                 return (0);
2804
2805         subj = SLOT(active_cred->cr_label);
2806         obj = SLOT(vplabel);
2807
2808         if (!mls_dominate_effective(subj, obj))
2809                 return (EACCES);
2810
2811         return (0);
2812 }
2813
2814 static int
2815 mls_check_vnode_unlink(struct ucred *cred, struct vnode *dvp,
2816     struct label *dvplabel, struct vnode *vp, struct label *vplabel,
2817     struct componentname *cnp)
2818 {
2819         struct mac_mls *subj, *obj;
2820
2821         if (!mls_enabled)
2822                 return (0);
2823
2824         subj = SLOT(cred->cr_label);
2825         obj = SLOT(dvplabel);
2826
2827         if (!mls_dominate_effective(obj, subj))
2828                 return (EACCES);
2829
2830         obj = SLOT(vplabel);
2831
2832         if (!mls_dominate_effective(obj, subj))
2833                 return (EACCES);
2834
2835         return (0);
2836 }
2837
2838 static int
2839 mls_check_vnode_write(struct ucred *active_cred, struct ucred *file_cred,
2840     struct vnode *vp, struct label *vplabel)
2841 {
2842         struct mac_mls *subj, *obj;
2843
2844         if (!mls_enabled || !revocation_enabled)
2845                 return (0);
2846
2847         subj = SLOT(active_cred->cr_label);
2848         obj = SLOT(vplabel);
2849
2850         if (!mls_dominate_effective(obj, subj))
2851                 return (EACCES);
2852
2853         return (0);
2854 }
2855
2856 static void
2857 mls_associate_nfsd_label(struct ucred *cred)
2858 {
2859         struct mac_mls *label;
2860
2861         label = SLOT(cred->cr_label);
2862         mls_set_effective(label, MAC_MLS_TYPE_LOW, 0, NULL);
2863         mls_set_range(label, MAC_MLS_TYPE_LOW, 0, NULL,
2864             MAC_MLS_TYPE_HIGH, 0, NULL);
2865 }
2866
2867 static struct mac_policy_ops mls_ops =
2868 {
2869         .mpo_init = mls_init,
2870         .mpo_init_bpfdesc_label = mls_init_label,
2871         .mpo_init_cred_label = mls_init_label,
2872         .mpo_init_devfs_label = mls_init_label,
2873         .mpo_init_ifnet_label = mls_init_label,
2874         .mpo_init_inpcb_label = mls_init_label_waitcheck,
2875         .mpo_init_syncache_label = mls_init_label_waitcheck,
2876         .mpo_init_sysv_msgmsg_label = mls_init_label,
2877         .mpo_init_sysv_msgqueue_label = mls_init_label,
2878         .mpo_init_sysv_sem_label = mls_init_label,
2879         .mpo_init_sysv_shm_label = mls_init_label,
2880         .mpo_init_ipq_label = mls_init_label_waitcheck,
2881         .mpo_init_mbuf_label = mls_init_label_waitcheck,
2882         .mpo_init_mount_label = mls_init_label,
2883         .mpo_init_pipe_label = mls_init_label,
2884         .mpo_init_posix_sem_label = mls_init_label,
2885         .mpo_init_socket_label = mls_init_label_waitcheck,
2886         .mpo_init_socket_peer_label = mls_init_label_waitcheck,
2887         .mpo_init_vnode_label = mls_init_label,
2888         .mpo_destroy_bpfdesc_label = mls_destroy_label,
2889         .mpo_destroy_cred_label = mls_destroy_label,
2890         .mpo_destroy_devfs_label = mls_destroy_label,
2891         .mpo_destroy_ifnet_label = mls_destroy_label,
2892         .mpo_destroy_inpcb_label = mls_destroy_label,
2893         .mpo_destroy_syncache_label = mls_destroy_label,
2894         .mpo_destroy_sysv_msgmsg_label = mls_destroy_label,
2895         .mpo_destroy_sysv_msgqueue_label = mls_destroy_label,
2896         .mpo_destroy_sysv_sem_label = mls_destroy_label,
2897         .mpo_destroy_sysv_shm_label = mls_destroy_label,
2898         .mpo_destroy_ipq_label = mls_destroy_label,
2899         .mpo_destroy_mbuf_label = mls_destroy_label,
2900         .mpo_destroy_mount_label = mls_destroy_label,
2901         .mpo_destroy_pipe_label = mls_destroy_label,
2902         .mpo_destroy_posix_sem_label = mls_destroy_label,
2903         .mpo_destroy_socket_label = mls_destroy_label,
2904         .mpo_destroy_socket_peer_label = mls_destroy_label,
2905         .mpo_destroy_vnode_label = mls_destroy_label,
2906         .mpo_copy_cred_label = mls_copy_label,
2907         .mpo_copy_ifnet_label = mls_copy_label,
2908         .mpo_copy_mbuf_label = mls_copy_label,
2909         .mpo_copy_pipe_label = mls_copy_label,
2910         .mpo_copy_socket_label = mls_copy_label,
2911         .mpo_copy_vnode_label = mls_copy_label,
2912         .mpo_externalize_cred_label = mls_externalize_label,
2913         .mpo_externalize_ifnet_label = mls_externalize_label,
2914         .mpo_externalize_pipe_label = mls_externalize_label,
2915         .mpo_externalize_socket_label = mls_externalize_label,
2916         .mpo_externalize_socket_peer_label = mls_externalize_label,
2917         .mpo_externalize_vnode_label = mls_externalize_label,
2918         .mpo_internalize_cred_label = mls_internalize_label,
2919         .mpo_internalize_ifnet_label = mls_internalize_label,
2920         .mpo_internalize_pipe_label = mls_internalize_label,
2921         .mpo_internalize_socket_label = mls_internalize_label,
2922         .mpo_internalize_vnode_label = mls_internalize_label,
2923         .mpo_create_devfs_device = mls_create_devfs_device,
2924         .mpo_create_devfs_directory = mls_create_devfs_directory,
2925         .mpo_create_devfs_symlink = mls_create_devfs_symlink,
2926         .mpo_create_mount = mls_create_mount,
2927         .mpo_relabel_vnode = mls_relabel_vnode,
2928         .mpo_update_devfs = mls_update_devfs,
2929         .mpo_associate_vnode_devfs = mls_associate_vnode_devfs,
2930         .mpo_associate_vnode_extattr = mls_associate_vnode_extattr,
2931         .mpo_associate_vnode_singlelabel = mls_associate_vnode_singlelabel,
2932         .mpo_create_vnode_extattr = mls_create_vnode_extattr,
2933         .mpo_setlabel_vnode_extattr = mls_setlabel_vnode_extattr,
2934         .mpo_create_mbuf_from_socket = mls_create_mbuf_from_socket,
2935         .mpo_create_mbuf_from_syncache = mls_create_mbuf_from_syncache,
2936         .mpo_create_pipe = mls_create_pipe,
2937         .mpo_create_posix_sem = mls_create_posix_sem,
2938         .mpo_create_socket = mls_create_socket,
2939         .mpo_create_socket_from_socket = mls_create_socket_from_socket,
2940         .mpo_relabel_pipe = mls_relabel_pipe,
2941         .mpo_relabel_socket = mls_relabel_socket,
2942         .mpo_set_socket_peer_from_mbuf = mls_set_socket_peer_from_mbuf,
2943         .mpo_set_socket_peer_from_socket = mls_set_socket_peer_from_socket,
2944         .mpo_create_bpfdesc = mls_create_bpfdesc,
2945         .mpo_create_datagram_from_ipq = mls_create_datagram_from_ipq,
2946         .mpo_create_fragment = mls_create_fragment,
2947         .mpo_create_ifnet = mls_create_ifnet,
2948         .mpo_create_inpcb_from_socket = mls_create_inpcb_from_socket,
2949         .mpo_init_syncache_from_inpcb = mls_init_syncache_from_inpcb,
2950         .mpo_create_ipq = mls_create_ipq,
2951         .mpo_create_sysv_msgmsg = mls_create_sysv_msgmsg,
2952         .mpo_create_sysv_msgqueue = mls_create_sysv_msgqueue,
2953         .mpo_create_sysv_sem = mls_create_sysv_sem,
2954         .mpo_create_sysv_shm = mls_create_sysv_shm,
2955         .mpo_create_mbuf_from_inpcb = mls_create_mbuf_from_inpcb,
2956         .mpo_create_mbuf_linklayer = mls_create_mbuf_linklayer,
2957         .mpo_create_mbuf_from_bpfdesc = mls_create_mbuf_from_bpfdesc,
2958         .mpo_create_mbuf_from_ifnet = mls_create_mbuf_from_ifnet,
2959         .mpo_create_mbuf_multicast_encap = mls_create_mbuf_multicast_encap,
2960         .mpo_create_mbuf_netlayer = mls_create_mbuf_netlayer,
2961         .mpo_fragment_match = mls_fragment_match,
2962         .mpo_relabel_ifnet = mls_relabel_ifnet,
2963         .mpo_update_ipq = mls_update_ipq,
2964         .mpo_inpcb_sosetlabel = mls_inpcb_sosetlabel,
2965         .mpo_create_proc0 = mls_create_proc0,
2966         .mpo_create_proc1 = mls_create_proc1,
2967         .mpo_relabel_cred = mls_relabel_cred,
2968         .mpo_cleanup_sysv_msgmsg = mls_cleanup_sysv_msgmsg,
2969         .mpo_cleanup_sysv_msgqueue = mls_cleanup_sysv_msgqueue,
2970         .mpo_cleanup_sysv_sem = mls_cleanup_sysv_sem,
2971         .mpo_cleanup_sysv_shm = mls_cleanup_sysv_shm,
2972         .mpo_check_bpfdesc_receive = mls_check_bpfdesc_receive,
2973         .mpo_check_cred_relabel = mls_check_cred_relabel,
2974         .mpo_check_cred_visible = mls_check_cred_visible,
2975         .mpo_check_ifnet_relabel = mls_check_ifnet_relabel,
2976         .mpo_check_ifnet_transmit = mls_check_ifnet_transmit,
2977         .mpo_check_inpcb_deliver = mls_check_inpcb_deliver,
2978         .mpo_check_inpcb_visible = mls_check_inpcb_visible,
2979         .mpo_check_sysv_msgrcv = mls_check_sysv_msgrcv,
2980         .mpo_check_sysv_msgrmid = mls_check_sysv_msgrmid,
2981         .mpo_check_sysv_msqget = mls_check_sysv_msqget,
2982         .mpo_check_sysv_msqsnd = mls_check_sysv_msqsnd,
2983         .mpo_check_sysv_msqrcv = mls_check_sysv_msqrcv,
2984         .mpo_check_sysv_msqctl = mls_check_sysv_msqctl,
2985         .mpo_check_sysv_semctl = mls_check_sysv_semctl,
2986         .mpo_check_sysv_semget = mls_check_sysv_semget,
2987         .mpo_check_sysv_semop = mls_check_sysv_semop,
2988         .mpo_check_sysv_shmat = mls_check_sysv_shmat,
2989         .mpo_check_sysv_shmctl = mls_check_sysv_shmctl,
2990         .mpo_check_sysv_shmget = mls_check_sysv_shmget,
2991         .mpo_check_mount_stat = mls_check_mount_stat,
2992         .mpo_check_pipe_ioctl = mls_check_pipe_ioctl,
2993         .mpo_check_pipe_poll = mls_check_pipe_poll,
2994         .mpo_check_pipe_read = mls_check_pipe_read,
2995         .mpo_check_pipe_relabel = mls_check_pipe_relabel,
2996         .mpo_check_pipe_stat = mls_check_pipe_stat,
2997         .mpo_check_pipe_write = mls_check_pipe_write,
2998         .mpo_check_posix_sem_destroy = mls_check_posix_sem_write,
2999         .mpo_check_posix_sem_getvalue = mls_check_posix_sem_rdonly,
3000         .mpo_check_posix_sem_open = mls_check_posix_sem_write,
3001         .mpo_check_posix_sem_post = mls_check_posix_sem_write,
3002         .mpo_check_posix_sem_unlink = mls_check_posix_sem_write,
3003         .mpo_check_posix_sem_wait = mls_check_posix_sem_write,
3004         .mpo_check_proc_debug = mls_check_proc_debug,
3005         .mpo_check_proc_sched = mls_check_proc_sched,
3006         .mpo_check_proc_signal = mls_check_proc_signal,
3007         .mpo_check_socket_deliver = mls_check_socket_deliver,
3008         .mpo_check_socket_relabel = mls_check_socket_relabel,
3009         .mpo_check_socket_visible = mls_check_socket_visible,
3010         .mpo_check_system_acct = mls_check_system_acct,
3011         .mpo_check_system_auditctl = mls_check_system_auditctl,
3012         .mpo_check_system_swapon = mls_check_system_swapon,
3013         .mpo_check_vnode_access = mls_check_vnode_open,
3014         .mpo_check_vnode_chdir = mls_check_vnode_chdir,
3015         .mpo_check_vnode_chroot = mls_check_vnode_chroot,
3016         .mpo_check_vnode_create = mls_check_vnode_create,
3017         .mpo_check_vnode_deleteacl = mls_check_vnode_deleteacl,
3018         .mpo_check_vnode_deleteextattr = mls_check_vnode_deleteextattr,
3019         .mpo_check_vnode_exec = mls_check_vnode_exec,
3020         .mpo_check_vnode_getacl = mls_check_vnode_getacl,
3021         .mpo_check_vnode_getextattr = mls_check_vnode_getextattr,
3022         .mpo_check_vnode_link = mls_check_vnode_link,
3023         .mpo_check_vnode_listextattr = mls_check_vnode_listextattr,
3024         .mpo_check_vnode_lookup = mls_check_vnode_lookup,
3025         .mpo_check_vnode_mmap = mls_check_vnode_mmap,
3026         .mpo_check_vnode_open = mls_check_vnode_open,
3027         .mpo_check_vnode_poll = mls_check_vnode_poll,
3028         .mpo_check_vnode_read = mls_check_vnode_read,
3029         .mpo_check_vnode_readdir = mls_check_vnode_readdir,
3030         .mpo_check_vnode_readlink = mls_check_vnode_readlink,
3031         .mpo_check_vnode_relabel = mls_check_vnode_relabel,
3032         .mpo_check_vnode_rename_from = mls_check_vnode_rename_from,
3033         .mpo_check_vnode_rename_to = mls_check_vnode_rename_to,
3034         .mpo_check_vnode_revoke = mls_check_vnode_revoke,
3035         .mpo_check_vnode_setacl = mls_check_vnode_setacl,
3036         .mpo_check_vnode_setextattr = mls_check_vnode_setextattr,
3037         .mpo_check_vnode_setflags = mls_check_vnode_setflags,
3038         .mpo_check_vnode_setmode = mls_check_vnode_setmode,
3039         .mpo_check_vnode_setowner = mls_check_vnode_setowner,
3040         .mpo_check_vnode_setutimes = mls_check_vnode_setutimes,
3041         .mpo_check_vnode_stat = mls_check_vnode_stat,
3042         .mpo_check_vnode_unlink = mls_check_vnode_unlink,
3043         .mpo_check_vnode_write = mls_check_vnode_write,
3044         .mpo_associate_nfsd_label = mls_associate_nfsd_label,
3045         .mpo_create_mbuf_from_firewall = mls_create_mbuf_from_firewall,
3046 };
3047
3048 MAC_POLICY_SET(&mls_ops, mac_mls, "TrustedBSD MAC/MLS",
3049     MPC_LOADTIME_FLAG_NOTLATE | MPC_LOADTIME_FLAG_LABELMBUFS, &mls_slot);