SAFE public projects git trees. - safe/jmp/linux-2.6/blob - security/selinux/ss/policydb.c

   1 /*
   2  * Implementation of the policy database.
   3  *
   4  * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
   5  */
   6
   7 /*
   8  * Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
   9  *
  10  *      Support for enhanced MLS infrastructure.
  11  *
  12  * Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
  13  *
  14  *      Added conditional policy language extensions
  15  *
  16  * Updated: Hewlett-Packard <paul.moore@hp.com>
  17  *
  18  *      Added support for the policy capability bitmap
  19  *
  20  * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
  21  * Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
  22  * Copyright (C) 2003 - 2004 Tresys Technology, LLC
  23  *      This program is free software; you can redistribute it and/or modify
  24  *      it under the terms of the GNU General Public License as published by
  25  *      the Free Software Foundation, version 2.
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/sched.h>
  30 #include <linux/slab.h>
  31 #include <linux/string.h>
  32 #include <linux/errno.h>
  33 #include <linux/audit.h>
  34 #include "security.h"
  35
  36 #include "policydb.h"
  37 #include "conditional.h"
  38 #include "mls.h"
  39
  40 #define _DEBUG_HASHES
  41
  42 #ifdef DEBUG_HASHES
  43 static char *symtab_name[SYM_NUM] = {
  44         "common prefixes",
  45         "classes",
  46         "roles",
  47         "types",
  48         "users",
  49         "bools",
  50         "levels",
  51         "categories",
  52 };
  53 #endif
  54
  55 int selinux_mls_enabled;
  56
  57 static unsigned int symtab_sizes[SYM_NUM] = {
  58         2,
  59         32,
  60         16,
  61         512,
  62         128,
  63         16,
  64         16,
  65         16,
  66 };
  67
  68 struct policydb_compat_info {
  69         int version;
  70         int sym_num;
  71         int ocon_num;
  72 };
  73
  74 /* These need to be updated if SYM_NUM or OCON_NUM changes */
  75 static struct policydb_compat_info policydb_compat[] = {
  76         {
  77                 .version        = POLICYDB_VERSION_BASE,
  78                 .sym_num        = SYM_NUM - 3,
  79                 .ocon_num       = OCON_NUM - 1,
  80         },
  81         {
  82                 .version        = POLICYDB_VERSION_BOOL,
  83                 .sym_num        = SYM_NUM - 2,
  84                 .ocon_num       = OCON_NUM - 1,
  85         },
  86         {
  87                 .version        = POLICYDB_VERSION_IPV6,
  88                 .sym_num        = SYM_NUM - 2,
  89                 .ocon_num       = OCON_NUM,
  90         },
  91         {
  92                 .version        = POLICYDB_VERSION_NLCLASS,
  93                 .sym_num        = SYM_NUM - 2,
  94                 .ocon_num       = OCON_NUM,
  95         },
  96         {
  97                 .version        = POLICYDB_VERSION_MLS,
  98                 .sym_num        = SYM_NUM,
  99                 .ocon_num       = OCON_NUM,
 100         },
 101         {
 102                 .version        = POLICYDB_VERSION_AVTAB,
 103                 .sym_num        = SYM_NUM,
 104                 .ocon_num       = OCON_NUM,
 105         },
 106         {
 107                 .version        = POLICYDB_VERSION_RANGETRANS,
 108                 .sym_num        = SYM_NUM,
 109                 .ocon_num       = OCON_NUM,
 110         },
 111         {
 112                 .version        = POLICYDB_VERSION_POLCAP,
 113                 .sym_num        = SYM_NUM,
 114                 .ocon_num       = OCON_NUM,
 115         },
 116         {
 117                 .version        = POLICYDB_VERSION_PERMISSIVE,
 118                 .sym_num        = SYM_NUM,
 119                 .ocon_num       = OCON_NUM,
 120         },
 121         {
 122                 .version        = POLICYDB_VERSION_BOUNDARY,
 123                 .sym_num        = SYM_NUM,
 124                 .ocon_num       = OCON_NUM,
 125         },
 126 };
 127
 128 static struct policydb_compat_info *policydb_lookup_compat(int version)
 129 {
 130         int i;
 131         struct policydb_compat_info *info = NULL;
 132
 133         for (i = 0; i < ARRAY_SIZE(policydb_compat); i++) {
 134                 if (policydb_compat[i].version == version) {
 135                         info = &policydb_compat[i];
 136                         break;
 137                 }
 138         }
 139         return info;
 140 }
 141
 142 /*
 143  * Initialize the role table.
 144  */
 145 static int roles_init(struct policydb *p)
 146 {
 147         char *key = NULL;
 148         int rc;
 149         struct role_datum *role;
 150
 151         role = kzalloc(sizeof(*role), GFP_KERNEL);
 152         if (!role) {
 153                 rc = -ENOMEM;
 154                 goto out;
 155         }
 156         role->value = ++p->p_roles.nprim;
 157         if (role->value != OBJECT_R_VAL) {
 158                 rc = -EINVAL;
 159                 goto out_free_role;
 160         }
 161         key = kmalloc(strlen(OBJECT_R)+1, GFP_KERNEL);
 162         if (!key) {
 163                 rc = -ENOMEM;
 164                 goto out_free_role;
 165         }
 166         strcpy(key, OBJECT_R);
 167         rc = hashtab_insert(p->p_roles.table, key, role);
 168         if (rc)
 169                 goto out_free_key;
 170 out:
 171         return rc;
 172
 173 out_free_key:
 174         kfree(key);
 175 out_free_role:
 176         kfree(role);
 177         goto out;
 178 }
 179
 180 /*
 181  * Initialize a policy database structure.
 182  */
 183 static int policydb_init(struct policydb *p)
 184 {
 185         int i, rc;
 186
 187         memset(p, 0, sizeof(*p));
 188
 189         for (i = 0; i < SYM_NUM; i++) {
 190                 rc = symtab_init(&p->symtab[i], symtab_sizes[i]);
 191                 if (rc)
 192                         goto out_free_symtab;
 193         }
 194
 195         rc = avtab_init(&p->te_avtab);
 196         if (rc)
 197                 goto out_free_symtab;
 198
 199         rc = roles_init(p);
 200         if (rc)
 201                 goto out_free_symtab;
 202
 203         rc = cond_policydb_init(p);
 204         if (rc)
 205                 goto out_free_symtab;
 206
 207         ebitmap_init(&p->policycaps);
 208         ebitmap_init(&p->permissive_map);
 209
 210 out:
 211         return rc;
 212
 213 out_free_symtab:
 214         for (i = 0; i < SYM_NUM; i++)
 215                 hashtab_destroy(p->symtab[i].table);
 216         goto out;
 217 }
 218
 219 /*
 220  * The following *_index functions are used to
 221  * define the val_to_name and val_to_struct arrays
 222  * in a policy database structure.  The val_to_name
 223  * arrays are used when converting security context
 224  * structures into string representations.  The
 225  * val_to_struct arrays are used when the attributes
 226  * of a class, role, or user are needed.
 227  */
 228
 229 static int common_index(void *key, void *datum, void *datap)
 230 {
 231         struct policydb *p;
 232         struct common_datum *comdatum;
 233
 234         comdatum = datum;
 235         p = datap;
 236         if (!comdatum->value || comdatum->value > p->p_commons.nprim)
 237                 return -EINVAL;
 238         p->p_common_val_to_name[comdatum->value - 1] = key;
 239         return 0;
 240 }
 241
 242 static int class_index(void *key, void *datum, void *datap)
 243 {
 244         struct policydb *p;
 245         struct class_datum *cladatum;
 246
 247         cladatum = datum;
 248         p = datap;
 249         if (!cladatum->value || cladatum->value > p->p_classes.nprim)
 250                 return -EINVAL;
 251         p->p_class_val_to_name[cladatum->value - 1] = key;
 252         p->class_val_to_struct[cladatum->value - 1] = cladatum;
 253         return 0;
 254 }
 255
 256 static int role_index(void *key, void *datum, void *datap)
 257 {
 258         struct policydb *p;
 259         struct role_datum *role;
 260
 261         role = datum;
 262         p = datap;
 263         if (!role->value
 264             || role->value > p->p_roles.nprim
 265             || role->bounds > p->p_roles.nprim)
 266                 return -EINVAL;
 267         p->p_role_val_to_name[role->value - 1] = key;
 268         p->role_val_to_struct[role->value - 1] = role;
 269         return 0;
 270 }
 271
 272 static int type_index(void *key, void *datum, void *datap)
 273 {
 274         struct policydb *p;
 275         struct type_datum *typdatum;
 276
 277         typdatum = datum;
 278         p = datap;
 279
 280         if (typdatum->primary) {
 281                 if (!typdatum->value
 282                     || typdatum->value > p->p_types.nprim
 283                     || typdatum->bounds > p->p_types.nprim)
 284                         return -EINVAL;
 285                 p->p_type_val_to_name[typdatum->value - 1] = key;
 286                 p->type_val_to_struct[typdatum->value - 1] = typdatum;
 287         }
 288
 289         return 0;
 290 }
 291
 292 static int user_index(void *key, void *datum, void *datap)
 293 {
 294         struct policydb *p;
 295         struct user_datum *usrdatum;
 296
 297         usrdatum = datum;
 298         p = datap;
 299         if (!usrdatum->value
 300             || usrdatum->value > p->p_users.nprim
 301             || usrdatum->bounds > p->p_users.nprim)
 302                 return -EINVAL;
 303         p->p_user_val_to_name[usrdatum->value - 1] = key;
 304         p->user_val_to_struct[usrdatum->value - 1] = usrdatum;
 305         return 0;
 306 }
 307
 308 static int sens_index(void *key, void *datum, void *datap)
 309 {
 310         struct policydb *p;
 311         struct level_datum *levdatum;
 312
 313         levdatum = datum;
 314         p = datap;
 315
 316         if (!levdatum->isalias) {
 317                 if (!levdatum->level->sens ||
 318                     levdatum->level->sens > p->p_levels.nprim)
 319                         return -EINVAL;
 320                 p->p_sens_val_to_name[levdatum->level->sens - 1] = key;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int cat_index(void *key, void *datum, void *datap)
 327 {
 328         struct policydb *p;
 329         struct cat_datum *catdatum;
 330
 331         catdatum = datum;
 332         p = datap;
 333
 334         if (!catdatum->isalias) {
 335                 if (!catdatum->value || catdatum->value > p->p_cats.nprim)
 336                         return -EINVAL;
 337                 p->p_cat_val_to_name[catdatum->value - 1] = key;
 338         }
 339
 340         return 0;
 341 }
 342
 343 static int (*index_f[SYM_NUM]) (void *key, void *datum, void *datap) =
 344 {
 345         common_index,
 346         class_index,
 347         role_index,
 348         type_index,
 349         user_index,
 350         cond_index_bool,
 351         sens_index,
 352         cat_index,
 353 };
 354
 355 /*
 356  * Define the common val_to_name array and the class
 357  * val_to_name and val_to_struct arrays in a policy
 358  * database structure.
 359  *
 360  * Caller must clean up upon failure.
 361  */
 362 static int policydb_index_classes(struct policydb *p)
 363 {
 364         int rc;
 365
 366         p->p_common_val_to_name =
 367                 kmalloc(p->p_commons.nprim * sizeof(char *), GFP_KERNEL);
 368         if (!p->p_common_val_to_name) {
 369                 rc = -ENOMEM;
 370                 goto out;
 371         }
 372
 373         rc = hashtab_map(p->p_commons.table, common_index, p);
 374         if (rc)
 375                 goto out;
 376
 377         p->class_val_to_struct =
 378                 kmalloc(p->p_classes.nprim * sizeof(*(p->class_val_to_struct)), GFP_KERNEL);
 379         if (!p->class_val_to_struct) {
 380                 rc = -ENOMEM;
 381                 goto out;
 382         }
 383
 384         p->p_class_val_to_name =
 385                 kmalloc(p->p_classes.nprim * sizeof(char *), GFP_KERNEL);
 386         if (!p->p_class_val_to_name) {
 387                 rc = -ENOMEM;
 388                 goto out;
 389         }
 390
 391         rc = hashtab_map(p->p_classes.table, class_index, p);
 392 out:
 393         return rc;
 394 }
 395
 396 #ifdef DEBUG_HASHES
 397 static void symtab_hash_eval(struct symtab *s)
 398 {
 399         int i;
 400
 401         for (i = 0; i < SYM_NUM; i++) {
 402                 struct hashtab *h = s[i].table;
 403                 struct hashtab_info info;
 404
 405                 hashtab_stat(h, &info);
 406                 printk(KERN_DEBUG "SELinux: %s:  %d entries and %d/%d buckets used, "
 407                        "longest chain length %d\n", symtab_name[i], h->nel,
 408                        info.slots_used, h->size, info.max_chain_len);
 409         }
 410 }
 411 #endif
 412
 413 /*
 414  * Define the other val_to_name and val_to_struct arrays
 415  * in a policy database structure.
 416  *
 417  * Caller must clean up on failure.
 418  */
 419 static int policydb_index_others(struct policydb *p)
 420 {
 421         int i, rc = 0;
 422
 423         printk(KERN_DEBUG "SELinux:  %d users, %d roles, %d types, %d bools",
 424                p->p_users.nprim, p->p_roles.nprim, p->p_types.nprim, p->p_bools.nprim);
 425         if (selinux_mls_enabled)
 426                 printk(", %d sens, %d cats", p->p_levels.nprim,
 427                        p->p_cats.nprim);
 428         printk("\n");
 429
 430         printk(KERN_DEBUG "SELinux:  %d classes, %d rules\n",
 431                p->p_classes.nprim, p->te_avtab.nel);
 432
 433 #ifdef DEBUG_HASHES
 434         avtab_hash_eval(&p->te_avtab, "rules");
 435         symtab_hash_eval(p->symtab);
 436 #endif
 437
 438         p->role_val_to_struct =
 439                 kmalloc(p->p_roles.nprim * sizeof(*(p->role_val_to_struct)),
 440                         GFP_KERNEL);
 441         if (!p->role_val_to_struct) {
 442                 rc = -ENOMEM;
 443                 goto out;
 444         }
 445
 446         p->user_val_to_struct =
 447                 kmalloc(p->p_users.nprim * sizeof(*(p->user_val_to_struct)),
 448                         GFP_KERNEL);
 449         if (!p->user_val_to_struct) {
 450                 rc = -ENOMEM;
 451                 goto out;
 452         }
 453
 454         p->type_val_to_struct =
 455                 kmalloc(p->p_types.nprim * sizeof(*(p->type_val_to_struct)),
 456                         GFP_KERNEL);
 457         if (!p->type_val_to_struct) {
 458                 rc = -ENOMEM;
 459                 goto out;
 460         }
 461
 462         if (cond_init_bool_indexes(p)) {
 463                 rc = -ENOMEM;
 464                 goto out;
 465         }
 466
 467         for (i = SYM_ROLES; i < SYM_NUM; i++) {
 468                 p->sym_val_to_name[i] =
 469                         kmalloc(p->symtab[i].nprim * sizeof(char *), GFP_KERNEL);
 470                 if (!p->sym_val_to_name[i]) {
 471                         rc = -ENOMEM;
 472                         goto out;
 473                 }
 474                 rc = hashtab_map(p->symtab[i].table, index_f[i], p);
 475                 if (rc)
 476                         goto out;
 477         }
 478
 479 out:
 480         return rc;
 481 }
 482
 483 /*
 484  * The following *_destroy functions are used to
 485  * free any memory allocated for each kind of
 486  * symbol data in the policy database.
 487  */
 488
 489 static int perm_destroy(void *key, void *datum, void *p)
 490 {
 491         kfree(key);
 492         kfree(datum);
 493         return 0;
 494 }
 495
 496 static int common_destroy(void *key, void *datum, void *p)
 497 {
 498         struct common_datum *comdatum;
 499
 500         kfree(key);
 501         comdatum = datum;
 502         hashtab_map(comdatum->permissions.table, perm_destroy, NULL);
 503         hashtab_destroy(comdatum->permissions.table);
 504         kfree(datum);
 505         return 0;
 506 }
 507
 508 static int cls_destroy(void *key, void *datum, void *p)
 509 {
 510         struct class_datum *cladatum;
 511         struct constraint_node *constraint, *ctemp;
 512         struct constraint_expr *e, *etmp;
 513
 514         kfree(key);
 515         cladatum = datum;
 516         hashtab_map(cladatum->permissions.table, perm_destroy, NULL);
 517         hashtab_destroy(cladatum->permissions.table);
 518         constraint = cladatum->constraints;
 519         while (constraint) {
 520                 e = constraint->expr;
 521                 while (e) {
 522                         ebitmap_destroy(&e->names);
 523                         etmp = e;
 524                         e = e->next;
 525                         kfree(etmp);
 526                 }
 527                 ctemp = constraint;
 528                 constraint = constraint->next;
 529                 kfree(ctemp);
 530         }
 531
 532         constraint = cladatum->validatetrans;
 533         while (constraint) {
 534                 e = constraint->expr;
 535                 while (e) {
 536                         ebitmap_destroy(&e->names);
 537                         etmp = e;
 538                         e = e->next;
 539                         kfree(etmp);
 540                 }
 541                 ctemp = constraint;
 542                 constraint = constraint->next;
 543                 kfree(ctemp);
 544         }
 545
 546         kfree(cladatum->comkey);
 547         kfree(datum);
 548         return 0;
 549 }
 550
 551 static int role_destroy(void *key, void *datum, void *p)
 552 {
 553         struct role_datum *role;
 554
 555         kfree(key);
 556         role = datum;
 557         ebitmap_destroy(&role->dominates);
 558         ebitmap_destroy(&role->types);
 559         kfree(datum);
 560         return 0;
 561 }
 562
 563 static int type_destroy(void *key, void *datum, void *p)
 564 {
 565         kfree(key);
 566         kfree(datum);
 567         return 0;
 568 }
 569
 570 static int user_destroy(void *key, void *datum, void *p)
 571 {
 572         struct user_datum *usrdatum;
 573
 574         kfree(key);
 575         usrdatum = datum;
 576         ebitmap_destroy(&usrdatum->roles);
 577         ebitmap_destroy(&usrdatum->range.level[0].cat);
 578         ebitmap_destroy(&usrdatum->range.level[1].cat);
 579         ebitmap_destroy(&usrdatum->dfltlevel.cat);
 580         kfree(datum);
 581         return 0;
 582 }
 583
 584 static int sens_destroy(void *key, void *datum, void *p)
 585 {
 586         struct level_datum *levdatum;
 587
 588         kfree(key);
 589         levdatum = datum;
 590         ebitmap_destroy(&levdatum->level->cat);
 591         kfree(levdatum->level);
 592         kfree(datum);
 593         return 0;
 594 }
 595
 596 static int cat_destroy(void *key, void *datum, void *p)
 597 {
 598         kfree(key);
 599         kfree(datum);
 600         return 0;
 601 }
 602
 603 static int (*destroy_f[SYM_NUM]) (void *key, void *datum, void *datap) =
 604 {
 605         common_destroy,
 606         cls_destroy,
 607         role_destroy,
 608         type_destroy,
 609         user_destroy,
 610         cond_destroy_bool,
 611         sens_destroy,
 612         cat_destroy,
 613 };
 614
 615 static void ocontext_destroy(struct ocontext *c, int i)
 616 {
 617         context_destroy(&c->context[0]);
 618         context_destroy(&c->context[1]);
 619         if (i == OCON_ISID || i == OCON_FS ||
 620             i == OCON_NETIF || i == OCON_FSUSE)
 621                 kfree(c->u.name);
 622         kfree(c);
 623 }
 624
 625 /*
 626  * Free any memory allocated by a policy database structure.
 627  */
 628 void policydb_destroy(struct policydb *p)
 629 {
 630         struct ocontext *c, *ctmp;
 631         struct genfs *g, *gtmp;
 632         int i;
 633         struct role_allow *ra, *lra = NULL;
 634         struct role_trans *tr, *ltr = NULL;
 635         struct range_trans *rt, *lrt = NULL;
 636
 637         for (i = 0; i < SYM_NUM; i++) {
 638                 cond_resched();
 639                 hashtab_map(p->symtab[i].table, destroy_f[i], NULL);
 640                 hashtab_destroy(p->symtab[i].table);
 641         }
 642
 643         for (i = 0; i < SYM_NUM; i++)
 644                 kfree(p->sym_val_to_name[i]);
 645
 646         kfree(p->class_val_to_struct);
 647         kfree(p->role_val_to_struct);
 648         kfree(p->user_val_to_struct);
 649         kfree(p->type_val_to_struct);
 650
 651         avtab_destroy(&p->te_avtab);
 652
 653         for (i = 0; i < OCON_NUM; i++) {
 654                 cond_resched();
 655                 c = p->ocontexts[i];
 656                 while (c) {
 657                         ctmp = c;
 658                         c = c->next;
 659                         ocontext_destroy(ctmp, i);
 660                 }
 661                 p->ocontexts[i] = NULL;
 662         }
 663
 664         g = p->genfs;
 665         while (g) {
 666                 cond_resched();
 667                 kfree(g->fstype);
 668                 c = g->head;
 669                 while (c) {
 670                         ctmp = c;
 671                         c = c->next;
 672                         ocontext_destroy(ctmp, OCON_FSUSE);
 673                 }
 674                 gtmp = g;
 675                 g = g->next;
 676                 kfree(gtmp);
 677         }
 678         p->genfs = NULL;
 679
 680         cond_policydb_destroy(p);
 681
 682         for (tr = p->role_tr; tr; tr = tr->next) {
 683                 cond_resched();
 684                 kfree(ltr);
 685                 ltr = tr;
 686         }
 687         kfree(ltr);
 688
 689         for (ra = p->role_allow; ra; ra = ra->next) {
 690                 cond_resched();
 691                 kfree(lra);
 692                 lra = ra;
 693         }
 694         kfree(lra);
 695
 696         for (rt = p->range_tr; rt; rt = rt->next) {
 697                 cond_resched();
 698                 if (lrt) {
 699                         ebitmap_destroy(&lrt->target_range.level[0].cat);
 700                         ebitmap_destroy(&lrt->target_range.level[1].cat);
 701                         kfree(lrt);
 702                 }
 703                 lrt = rt;
 704         }
 705         if (lrt) {
 706                 ebitmap_destroy(&lrt->target_range.level[0].cat);
 707                 ebitmap_destroy(&lrt->target_range.level[1].cat);
 708                 kfree(lrt);
 709         }
 710
 711         if (p->type_attr_map) {
 712                 for (i = 0; i < p->p_types.nprim; i++)
 713                         ebitmap_destroy(&p->type_attr_map[i]);
 714         }
 715         kfree(p->type_attr_map);
 716         kfree(p->undefined_perms);
 717         ebitmap_destroy(&p->policycaps);
 718         ebitmap_destroy(&p->permissive_map);
 719
 720         return;
 721 }
 722
 723 /*
 724  * Load the initial SIDs specified in a policy database
 725  * structure into a SID table.
 726  */
 727 int policydb_load_isids(struct policydb *p, struct sidtab *s)
 728 {
 729         struct ocontext *head, *c;
 730         int rc;
 731
 732         rc = sidtab_init(s);
 733         if (rc) {
 734                 printk(KERN_ERR "SELinux:  out of memory on SID table init\n");
 735                 goto out;
 736         }
 737
 738         head = p->ocontexts[OCON_ISID];
 739         for (c = head; c; c = c->next) {
 740                 if (!c->context[0].user) {
 741                         printk(KERN_ERR "SELinux:  SID %s was never "
 742                                "defined.\n", c->u.name);
 743                         rc = -EINVAL;
 744                         goto out;
 745                 }
 746                 if (sidtab_insert(s, c->sid[0], &c->context[0])) {
 747                         printk(KERN_ERR "SELinux:  unable to load initial "
 748                                "SID %s.\n", c->u.name);
 749                         rc = -EINVAL;
 750                         goto out;
 751                 }
 752         }
 753 out:
 754         return rc;
 755 }
 756
 757 int policydb_class_isvalid(struct policydb *p, unsigned int class)
 758 {
 759         if (!class || class > p->p_classes.nprim)
 760                 return 0;
 761         return 1;
 762 }
 763
 764 int policydb_role_isvalid(struct policydb *p, unsigned int role)
 765 {
 766         if (!role || role > p->p_roles.nprim)
 767                 return 0;
 768         return 1;
 769 }
 770
 771 int policydb_type_isvalid(struct policydb *p, unsigned int type)
 772 {
 773         if (!type || type > p->p_types.nprim)
 774                 return 0;
 775         return 1;
 776 }
 777
 778 /*
 779  * Return 1 if the fields in the security context
 780  * structure `c' are valid.  Return 0 otherwise.
 781  */
 782 int policydb_context_isvalid(struct policydb *p, struct context *c)
 783 {
 784         struct role_datum *role;
 785         struct user_datum *usrdatum;
 786
 787         if (!c->role || c->role > p->p_roles.nprim)
 788                 return 0;
 789
 790         if (!c->user || c->user > p->p_users.nprim)
 791                 return 0;
 792
 793         if (!c->type || c->type > p->p_types.nprim)
 794                 return 0;
 795
 796         if (c->role != OBJECT_R_VAL) {
 797                 /*
 798                  * Role must be authorized for the type.
 799                  */
 800                 role = p->role_val_to_struct[c->role - 1];
 801                 if (!ebitmap_get_bit(&role->types,
 802                                      c->type - 1))
 803                         /* role may not be associated with type */
 804                         return 0;
 805
 806                 /*
 807                  * User must be authorized for the role.
 808                  */
 809                 usrdatum = p->user_val_to_struct[c->user - 1];
 810                 if (!usrdatum)
 811                         return 0;
 812
 813                 if (!ebitmap_get_bit(&usrdatum->roles,
 814                                      c->role - 1))
 815                         /* user may not be associated with role */
 816                         return 0;
 817         }
 818
 819         if (!mls_context_isvalid(p, c))
 820                 return 0;
 821
 822         return 1;
 823 }
 824
 825 /*
 826  * Read a MLS range structure from a policydb binary
 827  * representation file.
 828  */
 829 static int mls_read_range_helper(struct mls_range *r, void *fp)
 830 {
 831         __le32 buf[2];
 832         u32 items;
 833         int rc;
 834
 835         rc = next_entry(buf, fp, sizeof(u32));
 836         if (rc < 0)
 837                 goto out;
 838
 839         items = le32_to_cpu(buf[0]);
 840         if (items > ARRAY_SIZE(buf)) {
 841                 printk(KERN_ERR "SELinux: mls:  range overflow\n");
 842                 rc = -EINVAL;
 843                 goto out;
 844         }
 845         rc = next_entry(buf, fp, sizeof(u32) * items);
 846         if (rc < 0) {
 847                 printk(KERN_ERR "SELinux: mls:  truncated range\n");
 848                 goto out;
 849         }
 850         r->level[0].sens = le32_to_cpu(buf[0]);
 851         if (items > 1)
 852                 r->level[1].sens = le32_to_cpu(buf[1]);
 853         else
 854                 r->level[1].sens = r->level[0].sens;
 855
 856         rc = ebitmap_read(&r->level[0].cat, fp);
 857         if (rc) {
 858                 printk(KERN_ERR "SELinux: mls:  error reading low "
 859                        "categories\n");
 860                 goto out;
 861         }
 862         if (items > 1) {
 863                 rc = ebitmap_read(&r->level[1].cat, fp);
 864                 if (rc) {
 865                         printk(KERN_ERR "SELinux: mls:  error reading high "
 866                                "categories\n");
 867                         goto bad_high;
 868                 }
 869         } else {
 870                 rc = ebitmap_cpy(&r->level[1].cat, &r->level[0].cat);
 871                 if (rc) {
 872                         printk(KERN_ERR "SELinux: mls:  out of memory\n");
 873                         goto bad_high;
 874                 }
 875         }
 876
 877         rc = 0;
 878 out:
 879         return rc;
 880 bad_high:
 881         ebitmap_destroy(&r->level[0].cat);
 882         goto out;
 883 }
 884
 885 /*
 886  * Read and validate a security context structure
 887  * from a policydb binary representation file.
 888  */
 889 static int context_read_and_validate(struct context *c,
 890                                      struct policydb *p,
 891                                      void *fp)
 892 {
 893         __le32 buf[3];
 894         int rc;
 895
 896         rc = next_entry(buf, fp, sizeof buf);
 897         if (rc < 0) {
 898                 printk(KERN_ERR "SELinux: context truncated\n");
 899                 goto out;
 900         }
 901         c->user = le32_to_cpu(buf[0]);
 902         c->role = le32_to_cpu(buf[1]);
 903         c->type = le32_to_cpu(buf[2]);
 904         if (p->policyvers >= POLICYDB_VERSION_MLS) {
 905                 if (mls_read_range_helper(&c->range, fp)) {
 906                         printk(KERN_ERR "SELinux: error reading MLS range of "
 907                                "context\n");
 908                         rc = -EINVAL;
 909                         goto out;
 910                 }
 911         }
 912
 913         if (!policydb_context_isvalid(p, c)) {
 914                 printk(KERN_ERR "SELinux:  invalid security context\n");
 915                 context_destroy(c);
 916                 rc = -EINVAL;
 917         }
 918 out:
 919         return rc;
 920 }
 921
 922 /*
 923  * The following *_read functions are used to
 924  * read the symbol data from a policy database
 925  * binary representation file.
 926  */
 927
 928 static int perm_read(struct policydb *p, struct hashtab *h, void *fp)
 929 {
 930         char *key = NULL;
 931         struct perm_datum *perdatum;
 932         int rc;
 933         __le32 buf[2];
 934         u32 len;
 935
 936         perdatum = kzalloc(sizeof(*perdatum), GFP_KERNEL);
 937         if (!perdatum) {
 938                 rc = -ENOMEM;
 939                 goto out;
 940         }
 941
 942         rc = next_entry(buf, fp, sizeof buf);
 943         if (rc < 0)
 944                 goto bad;
 945
 946         len = le32_to_cpu(buf[0]);
 947         perdatum->value = le32_to_cpu(buf[1]);
 948
 949         key = kmalloc(len + 1, GFP_KERNEL);
 950         if (!key) {
 951                 rc = -ENOMEM;
 952                 goto bad;
 953         }
 954         rc = next_entry(key, fp, len);
 955         if (rc < 0)
 956                 goto bad;
 957         key[len] = '\0';
 958
 959         rc = hashtab_insert(h, key, perdatum);
 960         if (rc)
 961                 goto bad;
 962 out:
 963         return rc;
 964 bad:
 965         perm_destroy(key, perdatum, NULL);
 966         goto out;
 967 }
 968
 969 static int common_read(struct policydb *p, struct hashtab *h, void *fp)
 970 {
 971         char *key = NULL;
 972         struct common_datum *comdatum;
 973         __le32 buf[4];
 974         u32 len, nel;
 975         int i, rc;
 976
 977         comdatum = kzalloc(sizeof(*comdatum), GFP_KERNEL);
 978         if (!comdatum) {
 979                 rc = -ENOMEM;
 980                 goto out;
 981         }
 982
 983         rc = next_entry(buf, fp, sizeof buf);
 984         if (rc < 0)
 985                 goto bad;
 986
 987         len = le32_to_cpu(buf[0]);
 988         comdatum->value = le32_to_cpu(buf[1]);
 989
 990         rc = symtab_init(&comdatum->permissions, PERM_SYMTAB_SIZE);
 991         if (rc)
 992                 goto bad;
 993         comdatum->permissions.nprim = le32_to_cpu(buf[2]);
 994         nel = le32_to_cpu(buf[3]);
 995
 996         key = kmalloc(len + 1, GFP_KERNEL);
 997         if (!key) {
 998                 rc = -ENOMEM;
 999                 goto bad;
1000         }
1001         rc = next_entry(key, fp, len);
1002         if (rc < 0)
1003                 goto bad;
1004         key[len] = '\0';
1005
1006         for (i = 0; i < nel; i++) {
1007                 rc = perm_read(p, comdatum->permissions.table, fp);
1008                 if (rc)
1009                         goto bad;
1010         }
1011
1012         rc = hashtab_insert(h, key, comdatum);
1013         if (rc)
1014                 goto bad;
1015 out:
1016         return rc;
1017 bad:
1018         common_destroy(key, comdatum, NULL);
1019         goto out;
1020 }
1021
1022 static int read_cons_helper(struct constraint_node **nodep, int ncons,
1023                             int allowxtarget, void *fp)
1024 {
1025         struct constraint_node *c, *lc;
1026         struct constraint_expr *e, *le;
1027         __le32 buf[3];
1028         u32 nexpr;
1029         int rc, i, j, depth;
1030
1031         lc = NULL;
1032         for (i = 0; i < ncons; i++) {
1033                 c = kzalloc(sizeof(*c), GFP_KERNEL);
1034                 if (!c)
1035                         return -ENOMEM;
1036
1037                 if (lc)
1038                         lc->next = c;
1039                 else
1040                         *nodep = c;
1041
1042                 rc = next_entry(buf, fp, (sizeof(u32) * 2));
1043                 if (rc < 0)
1044                         return rc;
1045                 c->permissions = le32_to_cpu(buf[0]);
1046                 nexpr = le32_to_cpu(buf[1]);
1047                 le = NULL;
1048                 depth = -1;
1049                 for (j = 0; j < nexpr; j++) {
1050                         e = kzalloc(sizeof(*e), GFP_KERNEL);
1051                         if (!e)
1052                                 return -ENOMEM;
1053
1054                         if (le)
1055                                 le->next = e;
1056                         else
1057                                 c->expr = e;
1058
1059                         rc = next_entry(buf, fp, (sizeof(u32) * 3));
1060                         if (rc < 0)
1061                                 return rc;
1062                         e->expr_type = le32_to_cpu(buf[0]);
1063                         e->attr = le32_to_cpu(buf[1]);
1064                         e->op = le32_to_cpu(buf[2]);
1065
1066                         switch (e->expr_type) {
1067                         case CEXPR_NOT:
1068                                 if (depth < 0)
1069                                         return -EINVAL;
1070                                 break;
1071                         case CEXPR_AND:
1072                         case CEXPR_OR:
1073                                 if (depth < 1)
1074                                         return -EINVAL;
1075                                 depth--;
1076                                 break;
1077                         case CEXPR_ATTR:
1078                                 if (depth == (CEXPR_MAXDEPTH - 1))
1079                                         return -EINVAL;
1080                                 depth++;
1081                                 break;
1082                         case CEXPR_NAMES:
1083                                 if (!allowxtarget && (e->attr & CEXPR_XTARGET))
1084                                         return -EINVAL;
1085                                 if (depth == (CEXPR_MAXDEPTH - 1))
1086                                         return -EINVAL;
1087                                 depth++;
1088                                 if (ebitmap_read(&e->names, fp))
1089                                         return -EINVAL;
1090                                 break;
1091                         default:
1092                                 return -EINVAL;
1093                         }
1094                         le = e;
1095                 }
1096                 if (depth != 0)
1097                         return -EINVAL;
1098                 lc = c;
1099         }
1100
1101         return 0;
1102 }
1103
1104 static int class_read(struct policydb *p, struct hashtab *h, void *fp)
1105 {
1106         char *key = NULL;
1107         struct class_datum *cladatum;
1108         __le32 buf[6];
1109         u32 len, len2, ncons, nel;
1110         int i, rc;
1111
1112         cladatum = kzalloc(sizeof(*cladatum), GFP_KERNEL);
1113         if (!cladatum) {
1114                 rc = -ENOMEM;
1115                 goto out;
1116         }
1117
1118         rc = next_entry(buf, fp, sizeof(u32)*6);
1119         if (rc < 0)
1120                 goto bad;
1121
1122         len = le32_to_cpu(buf[0]);
1123         len2 = le32_to_cpu(buf[1]);
1124         cladatum->value = le32_to_cpu(buf[2]);
1125
1126         rc = symtab_init(&cladatum->permissions, PERM_SYMTAB_SIZE);
1127         if (rc)
1128                 goto bad;
1129         cladatum->permissions.nprim = le32_to_cpu(buf[3]);
1130         nel = le32_to_cpu(buf[4]);
1131
1132         ncons = le32_to_cpu(buf[5]);
1133
1134         key = kmalloc(len + 1, GFP_KERNEL);
1135         if (!key) {
1136                 rc = -ENOMEM;
1137                 goto bad;
1138         }
1139         rc = next_entry(key, fp, len);
1140         if (rc < 0)
1141                 goto bad;
1142         key[len] = '\0';
1143
1144         if (len2) {
1145                 cladatum->comkey = kmalloc(len2 + 1, GFP_KERNEL);
1146                 if (!cladatum->comkey) {
1147                         rc = -ENOMEM;
1148                         goto bad;
1149                 }
1150                 rc = next_entry(cladatum->comkey, fp, len2);
1151                 if (rc < 0)
1152                         goto bad;
1153                 cladatum->comkey[len2] = '\0';
1154
1155                 cladatum->comdatum = hashtab_search(p->p_commons.table,
1156                                                     cladatum->comkey);
1157                 if (!cladatum->comdatum) {
1158                         printk(KERN_ERR "SELinux:  unknown common %s\n",
1159                                cladatum->comkey);
1160                         rc = -EINVAL;
1161                         goto bad;
1162                 }
1163         }
1164         for (i = 0; i < nel; i++) {
1165                 rc = perm_read(p, cladatum->permissions.table, fp);
1166                 if (rc)
1167                         goto bad;
1168         }
1169
1170         rc = read_cons_helper(&cladatum->constraints, ncons, 0, fp);
1171         if (rc)
1172                 goto bad;
1173
1174         if (p->policyvers >= POLICYDB_VERSION_VALIDATETRANS) {
1175                 /* grab the validatetrans rules */
1176                 rc = next_entry(buf, fp, sizeof(u32));
1177                 if (rc < 0)
1178                         goto bad;
1179                 ncons = le32_to_cpu(buf[0]);
1180                 rc = read_cons_helper(&cladatum->validatetrans, ncons, 1, fp);
1181                 if (rc)
1182                         goto bad;
1183         }
1184
1185         rc = hashtab_insert(h, key, cladatum);
1186         if (rc)
1187                 goto bad;
1188
1189         rc = 0;
1190 out:
1191         return rc;
1192 bad:
1193         cls_destroy(key, cladatum, NULL);
1194         goto out;
1195 }
1196
1197 static int role_read(struct policydb *p, struct hashtab *h, void *fp)
1198 {
1199         char *key = NULL;
1200         struct role_datum *role;
1201         int rc, to_read = 2;
1202         __le32 buf[3];
1203         u32 len;
1204
1205         role = kzalloc(sizeof(*role), GFP_KERNEL);
1206         if (!role) {
1207                 rc = -ENOMEM;
1208                 goto out;
1209         }
1210
1211         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1212                 to_read = 3;
1213
1214         rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1215         if (rc < 0)
1216                 goto bad;
1217
1218         len = le32_to_cpu(buf[0]);
1219         role->value = le32_to_cpu(buf[1]);
1220         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1221                 role->bounds = le32_to_cpu(buf[2]);
1222
1223         key = kmalloc(len + 1, GFP_KERNEL);
1224         if (!key) {
1225                 rc = -ENOMEM;
1226                 goto bad;
1227         }
1228         rc = next_entry(key, fp, len);
1229         if (rc < 0)
1230                 goto bad;
1231         key[len] = '\0';
1232
1233         rc = ebitmap_read(&role->dominates, fp);
1234         if (rc)
1235                 goto bad;
1236
1237         rc = ebitmap_read(&role->types, fp);
1238         if (rc)
1239                 goto bad;
1240
1241         if (strcmp(key, OBJECT_R) == 0) {
1242                 if (role->value != OBJECT_R_VAL) {
1243                         printk(KERN_ERR "SELinux: Role %s has wrong value %d\n",
1244                                OBJECT_R, role->value);
1245                         rc = -EINVAL;
1246                         goto bad;
1247                 }
1248                 rc = 0;
1249                 goto bad;
1250         }
1251
1252         rc = hashtab_insert(h, key, role);
1253         if (rc)
1254                 goto bad;
1255 out:
1256         return rc;
1257 bad:
1258         role_destroy(key, role, NULL);
1259         goto out;
1260 }
1261
1262 static int type_read(struct policydb *p, struct hashtab *h, void *fp)
1263 {
1264         char *key = NULL;
1265         struct type_datum *typdatum;
1266         int rc, to_read = 3;
1267         __le32 buf[4];
1268         u32 len;
1269
1270         typdatum = kzalloc(sizeof(*typdatum), GFP_KERNEL);
1271         if (!typdatum) {
1272                 rc = -ENOMEM;
1273                 return rc;
1274         }
1275
1276         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1277                 to_read = 4;
1278
1279         rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1280         if (rc < 0)
1281                 goto bad;
1282
1283         len = le32_to_cpu(buf[0]);
1284         typdatum->value = le32_to_cpu(buf[1]);
1285         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) {
1286                 u32 prop = le32_to_cpu(buf[2]);
1287
1288                 if (prop & TYPEDATUM_PROPERTY_PRIMARY)
1289                         typdatum->primary = 1;
1290                 if (prop & TYPEDATUM_PROPERTY_ATTRIBUTE)
1291                         typdatum->attribute = 1;
1292
1293                 typdatum->bounds = le32_to_cpu(buf[3]);
1294         } else {
1295                 typdatum->primary = le32_to_cpu(buf[2]);
1296         }
1297
1298         key = kmalloc(len + 1, GFP_KERNEL);
1299         if (!key) {
1300                 rc = -ENOMEM;
1301                 goto bad;
1302         }
1303         rc = next_entry(key, fp, len);
1304         if (rc < 0)
1305                 goto bad;
1306         key[len] = '\0';
1307
1308         rc = hashtab_insert(h, key, typdatum);
1309         if (rc)
1310                 goto bad;
1311 out:
1312         return rc;
1313 bad:
1314         type_destroy(key, typdatum, NULL);
1315         goto out;
1316 }
1317
1318
1319 /*
1320  * Read a MLS level structure from a policydb binary
1321  * representation file.
1322  */
1323 static int mls_read_level(struct mls_level *lp, void *fp)
1324 {
1325         __le32 buf[1];
1326         int rc;
1327
1328         memset(lp, 0, sizeof(*lp));
1329
1330         rc = next_entry(buf, fp, sizeof buf);
1331         if (rc < 0) {
1332                 printk(KERN_ERR "SELinux: mls: truncated level\n");
1333                 goto bad;
1334         }
1335         lp->sens = le32_to_cpu(buf[0]);
1336
1337         if (ebitmap_read(&lp->cat, fp)) {
1338                 printk(KERN_ERR "SELinux: mls:  error reading level "
1339                        "categories\n");
1340                 goto bad;
1341         }
1342
1343         return 0;
1344
1345 bad:
1346         return -EINVAL;
1347 }
1348
1349 static int user_read(struct policydb *p, struct hashtab *h, void *fp)
1350 {
1351         char *key = NULL;
1352         struct user_datum *usrdatum;
1353         int rc, to_read = 2;
1354         __le32 buf[3];
1355         u32 len;
1356
1357         usrdatum = kzalloc(sizeof(*usrdatum), GFP_KERNEL);
1358         if (!usrdatum) {
1359                 rc = -ENOMEM;
1360                 goto out;
1361         }
1362
1363         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1364                 to_read = 3;
1365
1366         rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1367         if (rc < 0)
1368                 goto bad;
1369
1370         len = le32_to_cpu(buf[0]);
1371         usrdatum->value = le32_to_cpu(buf[1]);
1372         if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1373                 usrdatum->bounds = le32_to_cpu(buf[2]);
1374
1375         key = kmalloc(len + 1, GFP_KERNEL);
1376         if (!key) {
1377                 rc = -ENOMEM;
1378                 goto bad;
1379         }
1380         rc = next_entry(key, fp, len);
1381         if (rc < 0)
1382                 goto bad;
1383         key[len] = '\0';
1384
1385         rc = ebitmap_read(&usrdatum->roles, fp);
1386         if (rc)
1387                 goto bad;
1388
1389         if (p->policyvers >= POLICYDB_VERSION_MLS) {
1390                 rc = mls_read_range_helper(&usrdatum->range, fp);
1391                 if (rc)
1392                         goto bad;
1393                 rc = mls_read_level(&usrdatum->dfltlevel, fp);
1394                 if (rc)
1395                         goto bad;
1396         }
1397
1398         rc = hashtab_insert(h, key, usrdatum);
1399         if (rc)
1400                 goto bad;
1401 out:
1402         return rc;
1403 bad:
1404         user_destroy(key, usrdatum, NULL);
1405         goto out;
1406 }
1407
1408 static int sens_read(struct policydb *p, struct hashtab *h, void *fp)
1409 {
1410         char *key = NULL;
1411         struct level_datum *levdatum;
1412         int rc;
1413         __le32 buf[2];
1414         u32 len;
1415
1416         levdatum = kzalloc(sizeof(*levdatum), GFP_ATOMIC);
1417         if (!levdatum) {
1418                 rc = -ENOMEM;
1419                 goto out;
1420         }
1421
1422         rc = next_entry(buf, fp, sizeof buf);
1423         if (rc < 0)
1424                 goto bad;
1425
1426         len = le32_to_cpu(buf[0]);
1427         levdatum->isalias = le32_to_cpu(buf[1]);
1428
1429         key = kmalloc(len + 1, GFP_ATOMIC);
1430         if (!key) {
1431                 rc = -ENOMEM;
1432                 goto bad;
1433         }
1434         rc = next_entry(key, fp, len);
1435         if (rc < 0)
1436                 goto bad;
1437         key[len] = '\0';
1438
1439         levdatum->level = kmalloc(sizeof(struct mls_level), GFP_ATOMIC);
1440         if (!levdatum->level) {
1441                 rc = -ENOMEM;
1442                 goto bad;
1443         }
1444         if (mls_read_level(levdatum->level, fp)) {
1445                 rc = -EINVAL;
1446                 goto bad;
1447         }
1448
1449         rc = hashtab_insert(h, key, levdatum);
1450         if (rc)
1451                 goto bad;
1452 out:
1453         return rc;
1454 bad:
1455         sens_destroy(key, levdatum, NULL);
1456         goto out;
1457 }
1458
1459 static int cat_read(struct policydb *p, struct hashtab *h, void *fp)
1460 {
1461         char *key = NULL;
1462         struct cat_datum *catdatum;
1463         int rc;
1464         __le32 buf[3];
1465         u32 len;
1466
1467         catdatum = kzalloc(sizeof(*catdatum), GFP_ATOMIC);
1468         if (!catdatum) {
1469                 rc = -ENOMEM;
1470                 goto out;
1471         }
1472
1473         rc = next_entry(buf, fp, sizeof buf);
1474         if (rc < 0)
1475                 goto bad;
1476
1477         len = le32_to_cpu(buf[0]);
1478         catdatum->value = le32_to_cpu(buf[1]);
1479         catdatum->isalias = le32_to_cpu(buf[2]);
1480
1481         key = kmalloc(len + 1, GFP_ATOMIC);
1482         if (!key) {
1483                 rc = -ENOMEM;
1484                 goto bad;
1485         }
1486         rc = next_entry(key, fp, len);
1487         if (rc < 0)
1488                 goto bad;
1489         key[len] = '\0';
1490
1491         rc = hashtab_insert(h, key, catdatum);
1492         if (rc)
1493                 goto bad;
1494 out:
1495         return rc;
1496
1497 bad:
1498         cat_destroy(key, catdatum, NULL);
1499         goto out;
1500 }
1501
1502 static int (*read_f[SYM_NUM]) (struct policydb *p, struct hashtab *h, void *fp) =
1503 {
1504         common_read,
1505         class_read,
1506         role_read,
1507         type_read,
1508         user_read,
1509         cond_read_bool,
1510         sens_read,
1511         cat_read,
1512 };
1513
1514 static int user_bounds_sanity_check(void *key, void *datum, void *datap)
1515 {
1516         struct user_datum *upper, *user;
1517         struct policydb *p = datap;
1518         int depth = 0;
1519
1520         upper = user = datum;
1521         while (upper->bounds) {
1522                 struct ebitmap_node *node;
1523                 unsigned long bit;
1524
1525                 if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1526                         printk(KERN_ERR "SELinux: user %s: "
1527                                "too deep or looped boundary",
1528                                (char *) key);
1529                         return -EINVAL;
1530                 }
1531
1532                 upper = p->user_val_to_struct[upper->bounds - 1];
1533                 ebitmap_for_each_positive_bit(&user->roles, node, bit) {
1534                         if (ebitmap_get_bit(&upper->roles, bit))
1535                                 continue;
1536
1537                         printk(KERN_ERR
1538                                "SELinux: boundary violated policy: "
1539                                "user=%s role=%s bounds=%s\n",
1540                                p->p_user_val_to_name[user->value - 1],
1541                                p->p_role_val_to_name[bit],
1542                                p->p_user_val_to_name[upper->value - 1]);
1543
1544                         return -EINVAL;
1545                 }
1546         }
1547
1548         return 0;
1549 }
1550
1551 static int role_bounds_sanity_check(void *key, void *datum, void *datap)
1552 {
1553         struct role_datum *upper, *role;
1554         struct policydb *p = datap;
1555         int depth = 0;
1556
1557         upper = role = datum;
1558         while (upper->bounds) {
1559                 struct ebitmap_node *node;
1560                 unsigned long bit;
1561
1562                 if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1563                         printk(KERN_ERR "SELinux: role %s: "
1564                                "too deep or looped bounds\n",
1565                                (char *) key);
1566                         return -EINVAL;
1567                 }
1568
1569                 upper = p->role_val_to_struct[upper->bounds - 1];
1570                 ebitmap_for_each_positive_bit(&role->types, node, bit) {
1571                         if (ebitmap_get_bit(&upper->types, bit))
1572                                 continue;
1573
1574                         printk(KERN_ERR
1575                                "SELinux: boundary violated policy: "
1576                                "role=%s type=%s bounds=%s\n",
1577                                p->p_role_val_to_name[role->value - 1],
1578                                p->p_type_val_to_name[bit],
1579                                p->p_role_val_to_name[upper->value - 1]);
1580
1581                         return -EINVAL;
1582                 }
1583         }
1584
1585         return 0;
1586 }
1587
1588 static int type_bounds_sanity_check(void *key, void *datum, void *datap)
1589 {
1590         struct type_datum *upper, *type;
1591         struct policydb *p = datap;
1592         int depth = 0;
1593
1594         upper = type = datum;
1595         while (upper->bounds) {
1596                 if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1597                         printk(KERN_ERR "SELinux: type %s: "
1598                                "too deep or looped boundary\n",
1599                                (char *) key);
1600                         return -EINVAL;
1601                 }
1602
1603                 upper = p->type_val_to_struct[upper->bounds - 1];
1604                 if (upper->attribute) {
1605                         printk(KERN_ERR "SELinux: type %s: "
1606                                "bounded by attribute %s",
1607                                (char *) key,
1608                                p->p_type_val_to_name[upper->value - 1]);
1609                         return -EINVAL;
1610                 }
1611         }
1612
1613         return 0;
1614 }
1615
1616 static int policydb_bounds_sanity_check(struct policydb *p)
1617 {
1618         int rc;
1619
1620         if (p->policyvers < POLICYDB_VERSION_BOUNDARY)
1621                 return 0;
1622
1623         rc = hashtab_map(p->p_users.table,
1624                          user_bounds_sanity_check, p);
1625         if (rc)
1626                 return rc;
1627
1628         rc = hashtab_map(p->p_roles.table,
1629                          role_bounds_sanity_check, p);
1630         if (rc)
1631                 return rc;
1632
1633         rc = hashtab_map(p->p_types.table,
1634                          type_bounds_sanity_check, p);
1635         if (rc)
1636                 return rc;
1637
1638         return 0;
1639 }
1640
1641 extern int ss_initialized;
1642
1643 /*
1644  * Read the configuration data from a policy database binary
1645  * representation file into a policy database structure.
1646  */
1647 int policydb_read(struct policydb *p, void *fp)
1648 {
1649         struct role_allow *ra, *lra;
1650         struct role_trans *tr, *ltr;
1651         struct ocontext *l, *c, *newc;
1652         struct genfs *genfs_p, *genfs, *newgenfs;
1653         int i, j, rc;
1654         __le32 buf[4];
1655         u32 nodebuf[8];
1656         u32 len, len2, config, nprim, nel, nel2;
1657         char *policydb_str;
1658         struct policydb_compat_info *info;
1659         struct range_trans *rt, *lrt;
1660
1661         config = 0;
1662
1663         rc = policydb_init(p);
1664         if (rc)
1665                 goto out;
1666
1667         /* Read the magic number and string length. */
1668         rc = next_entry(buf, fp, sizeof(u32) * 2);
1669         if (rc < 0)
1670                 goto bad;
1671
1672         if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) {
1673                 printk(KERN_ERR "SELinux:  policydb magic number 0x%x does "
1674                        "not match expected magic number 0x%x\n",
1675                        le32_to_cpu(buf[0]), POLICYDB_MAGIC);
1676                 goto bad;
1677         }
1678
1679         len = le32_to_cpu(buf[1]);
1680         if (len != strlen(POLICYDB_STRING)) {
1681                 printk(KERN_ERR "SELinux:  policydb string length %d does not "
1682                        "match expected length %Zu\n",
1683                        len, strlen(POLICYDB_STRING));
1684                 goto bad;
1685         }
1686         policydb_str = kmalloc(len + 1, GFP_KERNEL);
1687         if (!policydb_str) {
1688                 printk(KERN_ERR "SELinux:  unable to allocate memory for policydb "
1689                        "string of length %d\n", len);
1690                 rc = -ENOMEM;
1691                 goto bad;
1692         }
1693         rc = next_entry(policydb_str, fp, len);
1694         if (rc < 0) {
1695                 printk(KERN_ERR "SELinux:  truncated policydb string identifier\n");
1696                 kfree(policydb_str);
1697                 goto bad;
1698         }
1699         policydb_str[len] = '\0';
1700         if (strcmp(policydb_str, POLICYDB_STRING)) {
1701                 printk(KERN_ERR "SELinux:  policydb string %s does not match "
1702                        "my string %s\n", policydb_str, POLICYDB_STRING);
1703                 kfree(policydb_str);
1704                 goto bad;
1705         }
1706         /* Done with policydb_str. */
1707         kfree(policydb_str);
1708         policydb_str = NULL;
1709
1710         /* Read the version, config, and table sizes. */
1711         rc = next_entry(buf, fp, sizeof(u32)*4);
1712         if (rc < 0)
1713                 goto bad;
1714
1715         p->policyvers = le32_to_cpu(buf[0]);
1716         if (p->policyvers < POLICYDB_VERSION_MIN ||
1717             p->policyvers > POLICYDB_VERSION_MAX) {
1718                 printk(KERN_ERR "SELinux:  policydb version %d does not match "
1719                        "my version range %d-%d\n",
1720                        le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX);
1721                 goto bad;
1722         }
1723
1724         if ((le32_to_cpu(buf[1]) & POLICYDB_CONFIG_MLS)) {
1725                 if (ss_initialized && !selinux_mls_enabled) {
1726                         printk(KERN_ERR "SELinux: Cannot switch between non-MLS"
1727                                 " and MLS policies\n");
1728                         goto bad;
1729                 }
1730                 selinux_mls_enabled = 1;
1731                 config |= POLICYDB_CONFIG_MLS;
1732
1733                 if (p->policyvers < POLICYDB_VERSION_MLS) {
1734                         printk(KERN_ERR "SELinux: security policydb version %d "
1735                                 "(MLS) not backwards compatible\n",
1736                                 p->policyvers);
1737                         goto bad;
1738                 }
1739         } else {
1740                 if (ss_initialized && selinux_mls_enabled) {
1741                         printk(KERN_ERR "SELinux: Cannot switch between MLS and"
1742                                 " non-MLS policies\n");
1743                         goto bad;
1744                 }
1745         }
1746         p->reject_unknown = !!(le32_to_cpu(buf[1]) & REJECT_UNKNOWN);
1747         p->allow_unknown = !!(le32_to_cpu(buf[1]) & ALLOW_UNKNOWN);
1748
1749         if (p->policyvers >= POLICYDB_VERSION_POLCAP &&
1750             ebitmap_read(&p->policycaps, fp) != 0)
1751                 goto bad;
1752
1753         if (p->policyvers >= POLICYDB_VERSION_PERMISSIVE &&
1754             ebitmap_read(&p->permissive_map, fp) != 0)
1755                 goto bad;
1756
1757         info = policydb_lookup_compat(p->policyvers);
1758         if (!info) {
1759                 printk(KERN_ERR "SELinux:  unable to find policy compat info "
1760                        "for version %d\n", p->policyvers);
1761                 goto bad;
1762         }
1763
1764         if (le32_to_cpu(buf[2]) != info->sym_num ||
1765                 le32_to_cpu(buf[3]) != info->ocon_num) {
1766                 printk(KERN_ERR "SELinux:  policydb table sizes (%d,%d) do "
1767                        "not match mine (%d,%d)\n", le32_to_cpu(buf[2]),
1768                         le32_to_cpu(buf[3]),
1769                        info->sym_num, info->ocon_num);
1770                 goto bad;
1771         }
1772
1773         for (i = 0; i < info->sym_num; i++) {
1774                 rc = next_entry(buf, fp, sizeof(u32)*2);
1775                 if (rc < 0)
1776                         goto bad;
1777                 nprim = le32_to_cpu(buf[0]);
1778                 nel = le32_to_cpu(buf[1]);
1779                 for (j = 0; j < nel; j++) {
1780                         rc = read_f[i](p, p->symtab[i].table, fp);
1781                         if (rc)
1782                                 goto bad;
1783                 }
1784
1785                 p->symtab[i].nprim = nprim;
1786         }
1787
1788         rc = avtab_read(&p->te_avtab, fp, p);
1789         if (rc)
1790                 goto bad;
1791
1792         if (p->policyvers >= POLICYDB_VERSION_BOOL) {
1793                 rc = cond_read_list(p, fp);
1794                 if (rc)
1795                         goto bad;
1796         }
1797
1798         rc = next_entry(buf, fp, sizeof(u32));
1799         if (rc < 0)
1800                 goto bad;
1801         nel = le32_to_cpu(buf[0]);
1802         ltr = NULL;
1803         for (i = 0; i < nel; i++) {
1804                 tr = kzalloc(sizeof(*tr), GFP_KERNEL);
1805                 if (!tr) {
1806                         rc = -ENOMEM;
1807                         goto bad;
1808                 }
1809                 if (ltr)
1810                         ltr->next = tr;
1811                 else
1812                         p->role_tr = tr;
1813                 rc = next_entry(buf, fp, sizeof(u32)*3);
1814                 if (rc < 0)
1815                         goto bad;
1816                 tr->role = le32_to_cpu(buf[0]);
1817                 tr->type = le32_to_cpu(buf[1]);
1818                 tr->new_role = le32_to_cpu(buf[2]);
1819                 if (!policydb_role_isvalid(p, tr->role) ||
1820                     !policydb_type_isvalid(p, tr->type) ||
1821                     !policydb_role_isvalid(p, tr->new_role)) {
1822                         rc = -EINVAL;
1823                         goto bad;
1824                 }
1825                 ltr = tr;
1826         }
1827
1828         rc = next_entry(buf, fp, sizeof(u32));
1829         if (rc < 0)
1830                 goto bad;
1831         nel = le32_to_cpu(buf[0]);
1832         lra = NULL;
1833         for (i = 0; i < nel; i++) {
1834                 ra = kzalloc(sizeof(*ra), GFP_KERNEL);
1835                 if (!ra) {
1836                         rc = -ENOMEM;
1837                         goto bad;
1838                 }
1839                 if (lra)
1840                         lra->next = ra;
1841                 else
1842                         p->role_allow = ra;
1843                 rc = next_entry(buf, fp, sizeof(u32)*2);
1844                 if (rc < 0)
1845                         goto bad;
1846                 ra->role = le32_to_cpu(buf[0]);
1847                 ra->new_role = le32_to_cpu(buf[1]);
1848                 if (!policydb_role_isvalid(p, ra->role) ||
1849                     !policydb_role_isvalid(p, ra->new_role)) {
1850                         rc = -EINVAL;
1851                         goto bad;
1852                 }
1853                 lra = ra;
1854         }
1855
1856         rc = policydb_index_classes(p);
1857         if (rc)
1858                 goto bad;
1859
1860         rc = policydb_index_others(p);
1861         if (rc)
1862                 goto bad;
1863
1864         for (i = 0; i < info->ocon_num; i++) {
1865                 rc = next_entry(buf, fp, sizeof(u32));
1866                 if (rc < 0)
1867                         goto bad;
1868                 nel = le32_to_cpu(buf[0]);
1869                 l = NULL;
1870                 for (j = 0; j < nel; j++) {
1871                         c = kzalloc(sizeof(*c), GFP_KERNEL);
1872                         if (!c) {
1873                                 rc = -ENOMEM;
1874                                 goto bad;
1875                         }
1876                         if (l)
1877                                 l->next = c;
1878                         else
1879                                 p->ocontexts[i] = c;
1880                         l = c;
1881                         rc = -EINVAL;
1882                         switch (i) {
1883                         case OCON_ISID:
1884                                 rc = next_entry(buf, fp, sizeof(u32));
1885                                 if (rc < 0)
1886                                         goto bad;
1887                                 c->sid[0] = le32_to_cpu(buf[0]);
1888                                 rc = context_read_and_validate(&c->context[0], p, fp);
1889                                 if (rc)
1890                                         goto bad;
1891                                 break;
1892                         case OCON_FS:
1893                         case OCON_NETIF:
1894                                 rc = next_entry(buf, fp, sizeof(u32));
1895                                 if (rc < 0)
1896                                         goto bad;
1897                                 len = le32_to_cpu(buf[0]);
1898                                 c->u.name = kmalloc(len + 1, GFP_KERNEL);
1899                                 if (!c->u.name) {
1900                                         rc = -ENOMEM;
1901                                         goto bad;
1902                                 }
1903                                 rc = next_entry(c->u.name, fp, len);
1904                                 if (rc < 0)
1905                                         goto bad;
1906                                 c->u.name[len] = 0;
1907                                 rc = context_read_and_validate(&c->context[0], p, fp);
1908                                 if (rc)
1909                                         goto bad;
1910                                 rc = context_read_and_validate(&c->context[1], p, fp);
1911                                 if (rc)
1912                                         goto bad;
1913                                 break;
1914                         case OCON_PORT:
1915                                 rc = next_entry(buf, fp, sizeof(u32)*3);
1916                                 if (rc < 0)
1917                                         goto bad;
1918                                 c->u.port.protocol = le32_to_cpu(buf[0]);
1919                                 c->u.port.low_port = le32_to_cpu(buf[1]);
1920                                 c->u.port.high_port = le32_to_cpu(buf[2]);
1921                                 rc = context_read_and_validate(&c->context[0], p, fp);
1922                                 if (rc)
1923                                         goto bad;
1924                                 break;
1925                         case OCON_NODE:
1926                                 rc = next_entry(nodebuf, fp, sizeof(u32) * 2);
1927                                 if (rc < 0)
1928                                         goto bad;
1929                                 c->u.node.addr = nodebuf[0]; /* network order */
1930                                 c->u.node.mask = nodebuf[1]; /* network order */
1931                                 rc = context_read_and_validate(&c->context[0], p, fp);
1932                                 if (rc)
1933                                         goto bad;
1934                                 break;
1935                         case OCON_FSUSE:
1936                                 rc = next_entry(buf, fp, sizeof(u32)*2);
1937                                 if (rc < 0)
1938                                         goto bad;
1939                                 c->v.behavior = le32_to_cpu(buf[0]);
1940                                 if (c->v.behavior > SECURITY_FS_USE_NONE)
1941                                         goto bad;
1942                                 len = le32_to_cpu(buf[1]);
1943                                 c->u.name = kmalloc(len + 1, GFP_KERNEL);
1944                                 if (!c->u.name) {
1945                                         rc = -ENOMEM;
1946                                         goto bad;
1947                                 }
1948                                 rc = next_entry(c->u.name, fp, len);
1949                                 if (rc < 0)
1950                                         goto bad;
1951                                 c->u.name[len] = 0;
1952                                 rc = context_read_and_validate(&c->context[0], p, fp);
1953                                 if (rc)
1954                                         goto bad;
1955                                 break;
1956                         case OCON_NODE6: {
1957                                 int k;
1958
1959                                 rc = next_entry(nodebuf, fp, sizeof(u32) * 8);
1960                                 if (rc < 0)
1961                                         goto bad;
1962                                 for (k = 0; k < 4; k++)
1963                                         c->u.node6.addr[k] = nodebuf[k];
1964                                 for (k = 0; k < 4; k++)
1965                                         c->u.node6.mask[k] = nodebuf[k+4];
1966                                 if (context_read_and_validate(&c->context[0], p, fp))
1967                                         goto bad;
1968                                 break;
1969                         }
1970                         }
1971                 }
1972         }
1973
1974         rc = next_entry(buf, fp, sizeof(u32));
1975         if (rc < 0)
1976                 goto bad;
1977         nel = le32_to_cpu(buf[0]);
1978         genfs_p = NULL;
1979         rc = -EINVAL;
1980         for (i = 0; i < nel; i++) {
1981                 rc = next_entry(buf, fp, sizeof(u32));
1982                 if (rc < 0)
1983                         goto bad;
1984                 len = le32_to_cpu(buf[0]);
1985                 newgenfs = kzalloc(sizeof(*newgenfs), GFP_KERNEL);
1986                 if (!newgenfs) {
1987                         rc = -ENOMEM;
1988                         goto bad;
1989                 }
1990
1991                 newgenfs->fstype = kmalloc(len + 1, GFP_KERNEL);
1992                 if (!newgenfs->fstype) {
1993                         rc = -ENOMEM;
1994                         kfree(newgenfs);
1995                         goto bad;
1996                 }
1997                 rc = next_entry(newgenfs->fstype, fp, len);
1998                 if (rc < 0) {
1999                         kfree(newgenfs->fstype);
2000                         kfree(newgenfs);
2001                         goto bad;
2002                 }
2003                 newgenfs->fstype[len] = 0;
2004                 for (genfs_p = NULL, genfs = p->genfs; genfs;
2005                      genfs_p = genfs, genfs = genfs->next) {
2006                         if (strcmp(newgenfs->fstype, genfs->fstype) == 0) {
2007                                 printk(KERN_ERR "SELinux:  dup genfs "
2008                                        "fstype %s\n", newgenfs->fstype);
2009                                 kfree(newgenfs->fstype);
2010                                 kfree(newgenfs);
2011                                 goto bad;
2012                         }
2013                         if (strcmp(newgenfs->fstype, genfs->fstype) < 0)
2014                                 break;
2015                 }
2016                 newgenfs->next = genfs;
2017                 if (genfs_p)
2018                         genfs_p->next = newgenfs;
2019                 else
2020                         p->genfs = newgenfs;
2021                 rc = next_entry(buf, fp, sizeof(u32));
2022                 if (rc < 0)
2023                         goto bad;
2024                 nel2 = le32_to_cpu(buf[0]);
2025                 for (j = 0; j < nel2; j++) {
2026                         rc = next_entry(buf, fp, sizeof(u32));
2027                         if (rc < 0)
2028                                 goto bad;
2029                         len = le32_to_cpu(buf[0]);
2030
2031                         newc = kzalloc(sizeof(*newc), GFP_KERNEL);
2032                         if (!newc) {
2033                                 rc = -ENOMEM;
2034                                 goto bad;
2035                         }
2036
2037                         newc->u.name = kmalloc(len + 1, GFP_KERNEL);
2038                         if (!newc->u.name) {
2039                                 rc = -ENOMEM;
2040                                 goto bad_newc;
2041                         }
2042                         rc = next_entry(newc->u.name, fp, len);
2043                         if (rc < 0)
2044                                 goto bad_newc;
2045                         newc->u.name[len] = 0;
2046                         rc = next_entry(buf, fp, sizeof(u32));
2047                         if (rc < 0)
2048                                 goto bad_newc;
2049                         newc->v.sclass = le32_to_cpu(buf[0]);
2050                         if (context_read_and_validate(&newc->context[0], p, fp))
2051                                 goto bad_newc;
2052                         for (l = NULL, c = newgenfs->head; c;
2053                              l = c, c = c->next) {
2054                                 if (!strcmp(newc->u.name, c->u.name) &&
2055                                     (!c->v.sclass || !newc->v.sclass ||
2056                                      newc->v.sclass == c->v.sclass)) {
2057                                         printk(KERN_ERR "SELinux:  dup genfs "
2058                                                "entry (%s,%s)\n",
2059                                                newgenfs->fstype, c->u.name);
2060                                         goto bad_newc;
2061                                 }
2062                                 len = strlen(newc->u.name);
2063                                 len2 = strlen(c->u.name);
2064                                 if (len > len2)
2065                                         break;
2066                         }
2067
2068                         newc->next = c;
2069                         if (l)
2070                                 l->next = newc;
2071                         else
2072                                 newgenfs->head = newc;
2073                 }
2074         }
2075
2076         if (p->policyvers >= POLICYDB_VERSION_MLS) {
2077                 int new_rangetr = p->policyvers >= POLICYDB_VERSION_RANGETRANS;
2078                 rc = next_entry(buf, fp, sizeof(u32));
2079                 if (rc < 0)
2080                         goto bad;
2081                 nel = le32_to_cpu(buf[0]);
2082                 lrt = NULL;
2083                 for (i = 0; i < nel; i++) {
2084                         rt = kzalloc(sizeof(*rt), GFP_KERNEL);
2085                         if (!rt) {
2086                                 rc = -ENOMEM;
2087                                 goto bad;
2088                         }
2089                         if (lrt)
2090                                 lrt->next = rt;
2091                         else
2092                                 p->range_tr = rt;
2093                         rc = next_entry(buf, fp, (sizeof(u32) * 2));
2094                         if (rc < 0)
2095                                 goto bad;
2096                         rt->source_type = le32_to_cpu(buf[0]);
2097                         rt->target_type = le32_to_cpu(buf[1]);
2098                         if (new_rangetr) {
2099                                 rc = next_entry(buf, fp, sizeof(u32));
2100                                 if (rc < 0)
2101                                         goto bad;
2102                                 rt->target_class = le32_to_cpu(buf[0]);
2103                         } else
2104                                 rt->target_class = SECCLASS_PROCESS;
2105                         if (!policydb_type_isvalid(p, rt->source_type) ||
2106                             !policydb_type_isvalid(p, rt->target_type) ||
2107                             !policydb_class_isvalid(p, rt->target_class)) {
2108                                 rc = -EINVAL;
2109                                 goto bad;
2110                         }
2111                         rc = mls_read_range_helper(&rt->target_range, fp);
2112                         if (rc)
2113                                 goto bad;
2114                         if (!mls_range_isvalid(p, &rt->target_range)) {
2115                                 printk(KERN_WARNING "SELinux:  rangetrans:  invalid range\n");
2116                                 goto bad;
2117                         }
2118                         lrt = rt;
2119                 }
2120         }
2121
2122         p->type_attr_map = kmalloc(p->p_types.nprim*sizeof(struct ebitmap), GFP_KERNEL);
2123         if (!p->type_attr_map)
2124                 goto bad;
2125
2126         for (i = 0; i < p->p_types.nprim; i++) {
2127                 ebitmap_init(&p->type_attr_map[i]);
2128                 if (p->policyvers >= POLICYDB_VERSION_AVTAB) {
2129                         if (ebitmap_read(&p->type_attr_map[i], fp))
2130                                 goto bad;
2131                 }
2132                 /* add the type itself as the degenerate case */
2133                 if (ebitmap_set_bit(&p->type_attr_map[i], i, 1))
2134                                 goto bad;
2135         }
2136
2137         rc = policydb_bounds_sanity_check(p);
2138         if (rc)
2139                 goto bad;
2140
2141         rc = 0;
2142 out:
2143         return rc;
2144 bad_newc:
2145         ocontext_destroy(newc, OCON_FSUSE);
2146 bad:
2147         if (!rc)
2148                 rc = -EINVAL;
2149         policydb_destroy(p);
2150         goto out;
2151 }