1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Implementation of the policy database.
   4 *
   5 * Author : Stephen Smalley, <sds@tycho.nsa.gov>
   6 */
   7
   8/*
   9 * Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
  10 *
  11 *	Support for enhanced MLS infrastructure.
  12 *
  13 * Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
  14 *
  15 *	Added conditional policy language extensions
  16 *
  17 * Updated: Hewlett-Packard <paul@paul-moore.com>
  18 *
  19 *      Added support for the policy capability bitmap
  20 *
  21 * Update: Mellanox Techonologies
  22 *
  23 *	Added Infiniband support
  24 *
  25 * Copyright (C) 2016 Mellanox Techonologies
  26 * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
  27 * Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
  28 * Copyright (C) 2003 - 2004 Tresys Technology, LLC
 
 
 
  29 */
  30
  31#include <linux/kernel.h>
  32#include <linux/sched.h>
  33#include <linux/slab.h>
  34#include <linux/string.h>
  35#include <linux/errno.h>
  36#include <linux/audit.h>
 
  37#include "security.h"
  38
  39#include "policydb.h"
  40#include "conditional.h"
  41#include "mls.h"
  42#include "services.h"
  43
 
 
  44#ifdef DEBUG_HASHES
  45static const char *symtab_name[SYM_NUM] = {
  46	"common prefixes",
  47	"classes",
  48	"roles",
  49	"types",
  50	"users",
  51	"bools",
  52	"levels",
  53	"categories",
  54};
  55#endif
  56
 
 
 
 
 
 
 
 
 
 
 
  57struct policydb_compat_info {
  58	int version;
  59	int sym_num;
  60	int ocon_num;
  61};
  62
  63/* These need to be updated if SYM_NUM or OCON_NUM changes */
  64static const struct policydb_compat_info policydb_compat[] = {
  65	{
  66		.version	= POLICYDB_VERSION_BASE,
  67		.sym_num	= SYM_NUM - 3,
  68		.ocon_num	= OCON_NUM - 3,
  69	},
  70	{
  71		.version	= POLICYDB_VERSION_BOOL,
  72		.sym_num	= SYM_NUM - 2,
  73		.ocon_num	= OCON_NUM - 3,
  74	},
  75	{
  76		.version	= POLICYDB_VERSION_IPV6,
  77		.sym_num	= SYM_NUM - 2,
  78		.ocon_num	= OCON_NUM - 2,
  79	},
  80	{
  81		.version	= POLICYDB_VERSION_NLCLASS,
  82		.sym_num	= SYM_NUM - 2,
  83		.ocon_num	= OCON_NUM - 2,
  84	},
  85	{
  86		.version	= POLICYDB_VERSION_MLS,
  87		.sym_num	= SYM_NUM,
  88		.ocon_num	= OCON_NUM - 2,
  89	},
  90	{
  91		.version	= POLICYDB_VERSION_AVTAB,
  92		.sym_num	= SYM_NUM,
  93		.ocon_num	= OCON_NUM - 2,
  94	},
  95	{
  96		.version	= POLICYDB_VERSION_RANGETRANS,
  97		.sym_num	= SYM_NUM,
  98		.ocon_num	= OCON_NUM - 2,
  99	},
 100	{
 101		.version	= POLICYDB_VERSION_POLCAP,
 102		.sym_num	= SYM_NUM,
 103		.ocon_num	= OCON_NUM - 2,
 104	},
 105	{
 106		.version	= POLICYDB_VERSION_PERMISSIVE,
 107		.sym_num	= SYM_NUM,
 108		.ocon_num	= OCON_NUM - 2,
 109	},
 110	{
 111		.version	= POLICYDB_VERSION_BOUNDARY,
 112		.sym_num	= SYM_NUM,
 113		.ocon_num	= OCON_NUM - 2,
 114	},
 115	{
 116		.version	= POLICYDB_VERSION_FILENAME_TRANS,
 117		.sym_num	= SYM_NUM,
 118		.ocon_num	= OCON_NUM - 2,
 119	},
 120	{
 121		.version	= POLICYDB_VERSION_ROLETRANS,
 122		.sym_num	= SYM_NUM,
 123		.ocon_num	= OCON_NUM - 2,
 124	},
 125	{
 126		.version	= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS,
 127		.sym_num	= SYM_NUM,
 128		.ocon_num	= OCON_NUM - 2,
 129	},
 130	{
 131		.version	= POLICYDB_VERSION_DEFAULT_TYPE,
 132		.sym_num	= SYM_NUM,
 133		.ocon_num	= OCON_NUM - 2,
 134	},
 135	{
 136		.version	= POLICYDB_VERSION_CONSTRAINT_NAMES,
 137		.sym_num	= SYM_NUM,
 138		.ocon_num	= OCON_NUM - 2,
 139	},
 140	{
 141		.version	= POLICYDB_VERSION_XPERMS_IOCTL,
 142		.sym_num	= SYM_NUM,
 143		.ocon_num	= OCON_NUM - 2,
 144	},
 145	{
 146		.version	= POLICYDB_VERSION_INFINIBAND,
 147		.sym_num	= SYM_NUM,
 148		.ocon_num	= OCON_NUM,
 149	},
 150	{
 151		.version	= POLICYDB_VERSION_GLBLUB,
 152		.sym_num	= SYM_NUM,
 153		.ocon_num	= OCON_NUM,
 154	},
 155	{
 156		.version	= POLICYDB_VERSION_COMP_FTRANS,
 157		.sym_num	= SYM_NUM,
 158		.ocon_num	= OCON_NUM,
 159	},
 160};
 161
 162static const struct policydb_compat_info *policydb_lookup_compat(int version)
 163{
 164	int i;
 
 165
 166	for (i = 0; i < ARRAY_SIZE(policydb_compat); i++) {
 167		if (policydb_compat[i].version == version)
 168			return &policydb_compat[i];
 169	}
 170
 171	return NULL;
 172}
 173
 174/*
 175 * The following *_destroy functions are used to
 176 * free any memory allocated for each kind of
 177 * symbol data in the policy database.
 178 */
 179
 180static int perm_destroy(void *key, void *datum, void *p)
 181{
 182	kfree(key);
 183	kfree(datum);
 184	return 0;
 185}
 186
 187static int common_destroy(void *key, void *datum, void *p)
 188{
 189	struct common_datum *comdatum;
 190
 191	kfree(key);
 192	if (datum) {
 193		comdatum = datum;
 194		hashtab_map(&comdatum->permissions.table, perm_destroy, NULL);
 195		hashtab_destroy(&comdatum->permissions.table);
 196	}
 197	kfree(datum);
 198	return 0;
 199}
 200
 201static void constraint_expr_destroy(struct constraint_expr *expr)
 202{
 203	if (expr) {
 204		ebitmap_destroy(&expr->names);
 205		if (expr->type_names) {
 206			ebitmap_destroy(&expr->type_names->types);
 207			ebitmap_destroy(&expr->type_names->negset);
 208			kfree(expr->type_names);
 209		}
 210		kfree(expr);
 211	}
 212}
 213
 214static int cls_destroy(void *key, void *datum, void *p)
 215{
 216	struct class_datum *cladatum;
 217	struct constraint_node *constraint, *ctemp;
 218	struct constraint_expr *e, *etmp;
 219
 220	kfree(key);
 221	if (datum) {
 222		cladatum = datum;
 223		hashtab_map(&cladatum->permissions.table, perm_destroy, NULL);
 224		hashtab_destroy(&cladatum->permissions.table);
 225		constraint = cladatum->constraints;
 226		while (constraint) {
 227			e = constraint->expr;
 228			while (e) {
 229				etmp = e;
 230				e = e->next;
 231				constraint_expr_destroy(etmp);
 232			}
 233			ctemp = constraint;
 234			constraint = constraint->next;
 235			kfree(ctemp);
 236		}
 237
 238		constraint = cladatum->validatetrans;
 239		while (constraint) {
 240			e = constraint->expr;
 241			while (e) {
 242				etmp = e;
 243				e = e->next;
 244				constraint_expr_destroy(etmp);
 245			}
 246			ctemp = constraint;
 247			constraint = constraint->next;
 248			kfree(ctemp);
 249		}
 250		kfree(cladatum->comkey);
 251	}
 252	kfree(datum);
 253	return 0;
 254}
 255
 256static int role_destroy(void *key, void *datum, void *p)
 257{
 258	struct role_datum *role;
 259
 260	kfree(key);
 261	if (datum) {
 262		role = datum;
 263		ebitmap_destroy(&role->dominates);
 264		ebitmap_destroy(&role->types);
 265	}
 266	kfree(datum);
 267	return 0;
 268}
 269
 270static int type_destroy(void *key, void *datum, void *p)
 271{
 272	kfree(key);
 273	kfree(datum);
 274	return 0;
 275}
 276
 277static int user_destroy(void *key, void *datum, void *p)
 278{
 279	struct user_datum *usrdatum;
 280
 281	kfree(key);
 282	if (datum) {
 283		usrdatum = datum;
 284		ebitmap_destroy(&usrdatum->roles);
 285		ebitmap_destroy(&usrdatum->range.level[0].cat);
 286		ebitmap_destroy(&usrdatum->range.level[1].cat);
 287		ebitmap_destroy(&usrdatum->dfltlevel.cat);
 288	}
 289	kfree(datum);
 290	return 0;
 291}
 292
 293static int sens_destroy(void *key, void *datum, void *p)
 294{
 295	struct level_datum *levdatum;
 296
 297	kfree(key);
 298	if (datum) {
 299		levdatum = datum;
 300		if (levdatum->level)
 301			ebitmap_destroy(&levdatum->level->cat);
 302		kfree(levdatum->level);
 303	}
 304	kfree(datum);
 305	return 0;
 306}
 307
 308static int cat_destroy(void *key, void *datum, void *p)
 309{
 310	kfree(key);
 311	kfree(datum);
 312	return 0;
 313}
 314
 315static int (*const destroy_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
 316	common_destroy,
 317	cls_destroy,
 318	role_destroy,
 319	type_destroy,
 320	user_destroy,
 321	cond_destroy_bool,
 322	sens_destroy,
 323	cat_destroy,
 324};
 325
 326static int filenametr_destroy(void *key, void *datum, void *p)
 327{
 328	struct filename_trans_key *ft = key;
 329	struct filename_trans_datum *next, *d = datum;
 330
 331	kfree(ft->name);
 332	kfree(key);
 333	do {
 334		ebitmap_destroy(&d->stypes);
 335		next = d->next;
 336		kfree(d);
 337		d = next;
 338	} while (unlikely(d));
 339	cond_resched();
 340	return 0;
 341}
 342
 343static int range_tr_destroy(void *key, void *datum, void *p)
 344{
 345	struct mls_range *rt = datum;
 346
 347	kfree(key);
 348	ebitmap_destroy(&rt->level[0].cat);
 349	ebitmap_destroy(&rt->level[1].cat);
 350	kfree(datum);
 351	cond_resched();
 352	return 0;
 353}
 354
 355static int role_tr_destroy(void *key, void *datum, void *p)
 356{
 357	kfree(key);
 358	kfree(datum);
 359	return 0;
 360}
 361
 362static void ocontext_destroy(struct ocontext *c, int i)
 363{
 364	if (!c)
 365		return;
 366
 367	context_destroy(&c->context[0]);
 368	context_destroy(&c->context[1]);
 369	if (i == OCON_ISID || i == OCON_FS ||
 370	    i == OCON_NETIF || i == OCON_FSUSE)
 371		kfree(c->u.name);
 372	kfree(c);
 373}
 374
 375/*
 376 * Initialize the role table.
 377 */
 378static int roles_init(struct policydb *p)
 379{
 380	char *key = NULL;
 381	int rc;
 382	struct role_datum *role;
 383
 
 384	role = kzalloc(sizeof(*role), GFP_KERNEL);
 385	if (!role)
 386		return -ENOMEM;
 387
 388	rc = -EINVAL;
 389	role->value = ++p->p_roles.nprim;
 390	if (role->value != OBJECT_R_VAL)
 391		goto out;
 392
 393	rc = -ENOMEM;
 394	key = kstrdup(OBJECT_R, GFP_KERNEL);
 395	if (!key)
 396		goto out;
 397
 398	rc = symtab_insert(&p->p_roles, key, role);
 399	if (rc)
 400		goto out;
 401
 402	return 0;
 403out:
 404	kfree(key);
 405	kfree(role);
 406	return rc;
 407}
 408
 409static u32 filenametr_hash(const void *k)
 410{
 411	const struct filename_trans_key *ft = k;
 412	unsigned long hash;
 413	unsigned int byte_num;
 414	unsigned char focus;
 415
 416	hash = ft->ttype ^ ft->tclass;
 417
 418	byte_num = 0;
 419	while ((focus = ft->name[byte_num++]))
 420		hash = partial_name_hash(focus, hash);
 421	return hash;
 422}
 423
 424static int filenametr_cmp(const void *k1, const void *k2)
 425{
 426	const struct filename_trans_key *ft1 = k1;
 427	const struct filename_trans_key *ft2 = k2;
 428	int v;
 429
 
 
 
 
 430	v = ft1->ttype - ft2->ttype;
 431	if (v)
 432		return v;
 433
 434	v = ft1->tclass - ft2->tclass;
 435	if (v)
 436		return v;
 437
 438	return strcmp(ft1->name, ft2->name);
 439
 440}
 441
 442static const struct hashtab_key_params filenametr_key_params = {
 443	.hash = filenametr_hash,
 444	.cmp = filenametr_cmp,
 445};
 446
 447struct filename_trans_datum *policydb_filenametr_search(
 448	struct policydb *p, struct filename_trans_key *key)
 449{
 450	return hashtab_search(&p->filename_trans, key, filenametr_key_params);
 451}
 452
 453static u32 rangetr_hash(const void *k)
 454{
 455	const struct range_trans *key = k;
 456
 457	return key->source_type + (key->target_type << 3) +
 458		(key->target_class << 5);
 459}
 460
 461static int rangetr_cmp(const void *k1, const void *k2)
 462{
 463	const struct range_trans *key1 = k1, *key2 = k2;
 464	int v;
 465
 466	v = key1->source_type - key2->source_type;
 467	if (v)
 468		return v;
 469
 470	v = key1->target_type - key2->target_type;
 471	if (v)
 472		return v;
 473
 474	v = key1->target_class - key2->target_class;
 475
 476	return v;
 477}
 478
 479static const struct hashtab_key_params rangetr_key_params = {
 480	.hash = rangetr_hash,
 481	.cmp = rangetr_cmp,
 482};
 483
 484struct mls_range *policydb_rangetr_search(struct policydb *p,
 485					  struct range_trans *key)
 486{
 487	return hashtab_search(&p->range_tr, key, rangetr_key_params);
 488}
 489
 490static u32 role_trans_hash(const void *k)
 491{
 492	const struct role_trans_key *key = k;
 493
 494	return key->role + (key->type << 3) + (key->tclass << 5);
 495}
 496
 497static int role_trans_cmp(const void *k1, const void *k2)
 498{
 499	const struct role_trans_key *key1 = k1, *key2 = k2;
 500	int v;
 501
 502	v = key1->role - key2->role;
 503	if (v)
 504		return v;
 505
 506	v = key1->type - key2->type;
 507	if (v)
 508		return v;
 
 
 509
 510	return key1->tclass - key2->tclass;
 511}
 
 512
 513static const struct hashtab_key_params roletr_key_params = {
 514	.hash = role_trans_hash,
 515	.cmp = role_trans_cmp,
 516};
 517
 518struct role_trans_datum *policydb_roletr_search(struct policydb *p,
 519						struct role_trans_key *key)
 520{
 521	return hashtab_search(&p->role_tr, key, roletr_key_params);
 522}
 523
 524/*
 525 * Initialize a policy database structure.
 526 */
 527static void policydb_init(struct policydb *p)
 528{
 529	memset(p, 0, sizeof(*p));
 530
 531	avtab_init(&p->te_avtab);
 532	cond_policydb_init(p);
 
 533
 534	ebitmap_init(&p->filename_trans_ttypes);
 535	ebitmap_init(&p->policycaps);
 536	ebitmap_init(&p->permissive_map);
 
 
 
 
 
 
 
 
 537}
 538
 539/*
 540 * The following *_index functions are used to
 541 * define the val_to_name and val_to_struct arrays
 542 * in a policy database structure.  The val_to_name
 543 * arrays are used when converting security context
 544 * structures into string representations.  The
 545 * val_to_struct arrays are used when the attributes
 546 * of a class, role, or user are needed.
 547 */
 548
 549static int common_index(void *key, void *datum, void *datap)
 550{
 551	struct policydb *p;
 552	struct common_datum *comdatum;
 
 553
 554	comdatum = datum;
 555	p = datap;
 556	if (!comdatum->value || comdatum->value > p->p_commons.nprim)
 557		return -EINVAL;
 558
 559	p->sym_val_to_name[SYM_COMMONS][comdatum->value - 1] = key;
 560
 
 
 561	return 0;
 562}
 563
 564static int class_index(void *key, void *datum, void *datap)
 565{
 566	struct policydb *p;
 567	struct class_datum *cladatum;
 
 568
 569	cladatum = datum;
 570	p = datap;
 571	if (!cladatum->value || cladatum->value > p->p_classes.nprim)
 572		return -EINVAL;
 573
 574	p->sym_val_to_name[SYM_CLASSES][cladatum->value - 1] = key;
 
 
 575	p->class_val_to_struct[cladatum->value - 1] = cladatum;
 576	return 0;
 577}
 578
 579static int role_index(void *key, void *datum, void *datap)
 580{
 581	struct policydb *p;
 582	struct role_datum *role;
 
 583
 584	role = datum;
 585	p = datap;
 586	if (!role->value
 587	    || role->value > p->p_roles.nprim
 588	    || role->bounds > p->p_roles.nprim)
 589		return -EINVAL;
 590
 591	p->sym_val_to_name[SYM_ROLES][role->value - 1] = key;
 
 
 
 592	p->role_val_to_struct[role->value - 1] = role;
 593	return 0;
 594}
 595
 596static int type_index(void *key, void *datum, void *datap)
 597{
 598	struct policydb *p;
 599	struct type_datum *typdatum;
 
 600
 601	typdatum = datum;
 602	p = datap;
 603
 604	if (typdatum->primary) {
 605		if (!typdatum->value
 606		    || typdatum->value > p->p_types.nprim
 607		    || typdatum->bounds > p->p_types.nprim)
 608			return -EINVAL;
 609		p->sym_val_to_name[SYM_TYPES][typdatum->value - 1] = key;
 610		p->type_val_to_struct[typdatum->value - 1] = typdatum;
 
 
 
 
 
 
 
 611	}
 612
 613	return 0;
 614}
 615
 616static int user_index(void *key, void *datum, void *datap)
 617{
 618	struct policydb *p;
 619	struct user_datum *usrdatum;
 
 620
 621	usrdatum = datum;
 622	p = datap;
 623	if (!usrdatum->value
 624	    || usrdatum->value > p->p_users.nprim
 625	    || usrdatum->bounds > p->p_users.nprim)
 626		return -EINVAL;
 627
 628	p->sym_val_to_name[SYM_USERS][usrdatum->value - 1] = key;
 
 
 
 629	p->user_val_to_struct[usrdatum->value - 1] = usrdatum;
 630	return 0;
 631}
 632
 633static int sens_index(void *key, void *datum, void *datap)
 634{
 635	struct policydb *p;
 636	struct level_datum *levdatum;
 
 637
 638	levdatum = datum;
 639	p = datap;
 640
 641	if (!levdatum->isalias) {
 642		if (!levdatum->level->sens ||
 643		    levdatum->level->sens > p->p_levels.nprim)
 644			return -EINVAL;
 645
 646		p->sym_val_to_name[SYM_LEVELS][levdatum->level->sens - 1] = key;
 
 
 647	}
 648
 649	return 0;
 650}
 651
 652static int cat_index(void *key, void *datum, void *datap)
 653{
 654	struct policydb *p;
 655	struct cat_datum *catdatum;
 
 656
 657	catdatum = datum;
 658	p = datap;
 659
 660	if (!catdatum->isalias) {
 661		if (!catdatum->value || catdatum->value > p->p_cats.nprim)
 662			return -EINVAL;
 663
 664		p->sym_val_to_name[SYM_CATS][catdatum->value - 1] = key;
 
 
 665	}
 666
 667	return 0;
 668}
 669
 670static int (*const index_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
 
 671	common_index,
 672	class_index,
 673	role_index,
 674	type_index,
 675	user_index,
 676	cond_index_bool,
 677	sens_index,
 678	cat_index,
 679};
 680
 681#ifdef DEBUG_HASHES
 682static void hash_eval(struct hashtab *h, const char *hash_name)
 683{
 684	struct hashtab_info info;
 685
 686	hashtab_stat(h, &info);
 687	pr_debug("SELinux: %s:  %d entries and %d/%d buckets used, longest chain length %d\n",
 688		 hash_name, h->nel, info.slots_used, h->size,
 689		 info.max_chain_len);
 690}
 691
 692static void symtab_hash_eval(struct symtab *s)
 693{
 694	int i;
 695
 696	for (i = 0; i < SYM_NUM; i++)
 697		hash_eval(&s[i].table, symtab_name[i]);
 698}
 699
 700#else
 701static inline void hash_eval(struct hashtab *h, const char *hash_name)
 702{
 703}
 704#endif
 705
 706/*
 707 * Define the other val_to_name and val_to_struct arrays
 708 * in a policy database structure.
 709 *
 710 * Caller must clean up on failure.
 711 */
 712static int policydb_index(struct policydb *p)
 713{
 714	int i, rc;
 715
 
 
 716	if (p->mls_enabled)
 717		pr_debug("SELinux:  %d users, %d roles, %d types, %d bools, %d sens, %d cats\n",
 718			 p->p_users.nprim, p->p_roles.nprim, p->p_types.nprim,
 719			 p->p_bools.nprim, p->p_levels.nprim, p->p_cats.nprim);
 720	else
 721		pr_debug("SELinux:  %d users, %d roles, %d types, %d bools\n",
 722			 p->p_users.nprim, p->p_roles.nprim, p->p_types.nprim,
 723			 p->p_bools.nprim);
 724
 725	pr_debug("SELinux:  %d classes, %d rules\n",
 726		 p->p_classes.nprim, p->te_avtab.nel);
 727
 728#ifdef DEBUG_HASHES
 729	avtab_hash_eval(&p->te_avtab, "rules");
 730	symtab_hash_eval(p->symtab);
 731#endif
 732
 733	p->class_val_to_struct = kcalloc(p->p_classes.nprim,
 734					 sizeof(*p->class_val_to_struct),
 735					 GFP_KERNEL);
 
 736	if (!p->class_val_to_struct)
 737		return -ENOMEM;
 738
 739	p->role_val_to_struct = kcalloc(p->p_roles.nprim,
 740					sizeof(*p->role_val_to_struct),
 741					GFP_KERNEL);
 
 742	if (!p->role_val_to_struct)
 743		return -ENOMEM;
 744
 745	p->user_val_to_struct = kcalloc(p->p_users.nprim,
 746					sizeof(*p->user_val_to_struct),
 747					GFP_KERNEL);
 
 748	if (!p->user_val_to_struct)
 749		return -ENOMEM;
 750
 751	p->type_val_to_struct = kvcalloc(p->p_types.nprim,
 752					 sizeof(*p->type_val_to_struct),
 753					 GFP_KERNEL);
 754	if (!p->type_val_to_struct)
 755		return -ENOMEM;
 
 
 
 
 
 
 
 756
 757	rc = cond_init_bool_indexes(p);
 758	if (rc)
 759		goto out;
 760
 761	for (i = 0; i < SYM_NUM; i++) {
 762		p->sym_val_to_name[i] = kvcalloc(p->symtab[i].nprim,
 763						 sizeof(char *),
 764						 GFP_KERNEL);
 
 765		if (!p->sym_val_to_name[i])
 766			return -ENOMEM;
 767
 768		rc = hashtab_map(&p->symtab[i].table, index_f[i], p);
 
 
 
 
 
 
 769		if (rc)
 770			goto out;
 771	}
 772	rc = 0;
 773out:
 774	return rc;
 775}
 776
 777/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 778 * Free any memory allocated by a policy database structure.
 779 */
 780void policydb_destroy(struct policydb *p)
 781{
 782	struct ocontext *c, *ctmp;
 783	struct genfs *g, *gtmp;
 784	int i;
 785	struct role_allow *ra, *lra = NULL;
 
 786
 787	for (i = 0; i < SYM_NUM; i++) {
 788		cond_resched();
 789		hashtab_map(&p->symtab[i].table, destroy_f[i], NULL);
 790		hashtab_destroy(&p->symtab[i].table);
 791	}
 792
 793	for (i = 0; i < SYM_NUM; i++)
 794		kvfree(p->sym_val_to_name[i]);
 
 
 795
 796	kfree(p->class_val_to_struct);
 797	kfree(p->role_val_to_struct);
 798	kfree(p->user_val_to_struct);
 799	kvfree(p->type_val_to_struct);
 
 800
 801	avtab_destroy(&p->te_avtab);
 802
 803	for (i = 0; i < OCON_NUM; i++) {
 804		cond_resched();
 805		c = p->ocontexts[i];
 806		while (c) {
 807			ctmp = c;
 808			c = c->next;
 809			ocontext_destroy(ctmp, i);
 810		}
 811		p->ocontexts[i] = NULL;
 812	}
 813
 814	g = p->genfs;
 815	while (g) {
 816		cond_resched();
 817		kfree(g->fstype);
 818		c = g->head;
 819		while (c) {
 820			ctmp = c;
 821			c = c->next;
 822			ocontext_destroy(ctmp, OCON_FSUSE);
 823		}
 824		gtmp = g;
 825		g = g->next;
 826		kfree(gtmp);
 827	}
 828	p->genfs = NULL;
 829
 830	cond_policydb_destroy(p);
 831
 832	hashtab_map(&p->role_tr, role_tr_destroy, NULL);
 833	hashtab_destroy(&p->role_tr);
 
 
 
 
 834
 835	for (ra = p->role_allow; ra; ra = ra->next) {
 836		cond_resched();
 837		kfree(lra);
 838		lra = ra;
 839	}
 840	kfree(lra);
 841
 842	hashtab_map(&p->filename_trans, filenametr_destroy, NULL);
 843	hashtab_destroy(&p->filename_trans);
 844
 845	hashtab_map(&p->range_tr, range_tr_destroy, NULL);
 846	hashtab_destroy(&p->range_tr);
 847
 848	if (p->type_attr_map_array) {
 849		for (i = 0; i < p->p_types.nprim; i++)
 850			ebitmap_destroy(&p->type_attr_map_array[i]);
 851		kvfree(p->type_attr_map_array);
 
 
 
 
 
 
 852	}
 853
 854	ebitmap_destroy(&p->filename_trans_ttypes);
 855	ebitmap_destroy(&p->policycaps);
 856	ebitmap_destroy(&p->permissive_map);
 
 
 857}
 858
 859/*
 860 * Load the initial SIDs specified in a policy database
 861 * structure into a SID table.
 862 */
 863int policydb_load_isids(struct policydb *p, struct sidtab *s)
 864{
 865	struct ocontext *head, *c;
 866	int rc;
 867
 868	rc = sidtab_init(s);
 869	if (rc) {
 870		pr_err("SELinux:  out of memory on SID table init\n");
 871		return rc;
 872	}
 873
 874	head = p->ocontexts[OCON_ISID];
 875	for (c = head; c; c = c->next) {
 876		u32 sid = c->sid[0];
 877		const char *name = security_get_initial_sid_context(sid);
 878
 879		if (sid == SECSID_NULL) {
 880			pr_err("SELinux:  SID 0 was assigned a context.\n");
 881			sidtab_destroy(s);
 882			return -EINVAL;
 883		}
 884
 885		/* Ignore initial SIDs unused by this kernel. */
 886		if (!name)
 887			continue;
 888
 889		rc = sidtab_set_initial(s, sid, &c->context[0]);
 890		if (rc) {
 891			pr_err("SELinux:  unable to load initial SID %s.\n",
 892			       name);
 893			sidtab_destroy(s);
 894			return rc;
 895		}
 896	}
 897	return 0;
 
 
 898}
 899
 900int policydb_class_isvalid(struct policydb *p, unsigned int class)
 901{
 902	if (!class || class > p->p_classes.nprim)
 903		return 0;
 904	return 1;
 905}
 906
 907int policydb_role_isvalid(struct policydb *p, unsigned int role)
 908{
 909	if (!role || role > p->p_roles.nprim)
 910		return 0;
 911	return 1;
 912}
 913
 914int policydb_type_isvalid(struct policydb *p, unsigned int type)
 915{
 916	if (!type || type > p->p_types.nprim)
 917		return 0;
 918	return 1;
 919}
 920
 921/*
 922 * Return 1 if the fields in the security context
 923 * structure `c' are valid.  Return 0 otherwise.
 924 */
 925int policydb_context_isvalid(struct policydb *p, struct context *c)
 926{
 927	struct role_datum *role;
 928	struct user_datum *usrdatum;
 929
 930	if (!c->role || c->role > p->p_roles.nprim)
 931		return 0;
 932
 933	if (!c->user || c->user > p->p_users.nprim)
 934		return 0;
 935
 936	if (!c->type || c->type > p->p_types.nprim)
 937		return 0;
 938
 939	if (c->role != OBJECT_R_VAL) {
 940		/*
 941		 * Role must be authorized for the type.
 942		 */
 943		role = p->role_val_to_struct[c->role - 1];
 944		if (!role || !ebitmap_get_bit(&role->types, c->type - 1))
 945			/* role may not be associated with type */
 946			return 0;
 947
 948		/*
 949		 * User must be authorized for the role.
 950		 */
 951		usrdatum = p->user_val_to_struct[c->user - 1];
 952		if (!usrdatum)
 953			return 0;
 954
 955		if (!ebitmap_get_bit(&usrdatum->roles, c->role - 1))
 956			/* user may not be associated with role */
 957			return 0;
 958	}
 959
 960	if (!mls_context_isvalid(p, c))
 961		return 0;
 962
 963	return 1;
 964}
 965
 966/*
 967 * Read a MLS range structure from a policydb binary
 968 * representation file.
 969 */
 970static int mls_read_range_helper(struct mls_range *r, void *fp)
 971{
 972	__le32 buf[2];
 973	u32 items;
 974	int rc;
 975
 976	rc = next_entry(buf, fp, sizeof(u32));
 977	if (rc)
 978		goto out;
 979
 980	rc = -EINVAL;
 981	items = le32_to_cpu(buf[0]);
 982	if (items > ARRAY_SIZE(buf)) {
 983		pr_err("SELinux: mls:  range overflow\n");
 984		goto out;
 985	}
 986
 987	rc = next_entry(buf, fp, sizeof(u32) * items);
 988	if (rc) {
 989		pr_err("SELinux: mls:  truncated range\n");
 990		goto out;
 991	}
 992
 993	r->level[0].sens = le32_to_cpu(buf[0]);
 994	if (items > 1)
 995		r->level[1].sens = le32_to_cpu(buf[1]);
 996	else
 997		r->level[1].sens = r->level[0].sens;
 998
 999	rc = ebitmap_read(&r->level[0].cat, fp);
1000	if (rc) {
1001		pr_err("SELinux: mls:  error reading low categories\n");
1002		goto out;
1003	}
1004	if (items > 1) {
1005		rc = ebitmap_read(&r->level[1].cat, fp);
1006		if (rc) {
1007			pr_err("SELinux: mls:  error reading high categories\n");
1008			goto bad_high;
1009		}
1010	} else {
1011		rc = ebitmap_cpy(&r->level[1].cat, &r->level[0].cat);
1012		if (rc) {
1013			pr_err("SELinux: mls:  out of memory\n");
1014			goto bad_high;
1015		}
1016	}
1017
1018	return 0;
1019bad_high:
1020	ebitmap_destroy(&r->level[0].cat);
1021out:
1022	return rc;
1023}
1024
1025/*
1026 * Read and validate a security context structure
1027 * from a policydb binary representation file.
1028 */
1029static int context_read_and_validate(struct context *c,
1030				     struct policydb *p,
1031				     void *fp)
1032{
1033	__le32 buf[3];
1034	int rc;
1035
1036	rc = next_entry(buf, fp, sizeof buf);
1037	if (rc) {
1038		pr_err("SELinux: context truncated\n");
1039		goto out;
1040	}
1041	c->user = le32_to_cpu(buf[0]);
1042	c->role = le32_to_cpu(buf[1]);
1043	c->type = le32_to_cpu(buf[2]);
1044	if (p->policyvers >= POLICYDB_VERSION_MLS) {
1045		rc = mls_read_range_helper(&c->range, fp);
1046		if (rc) {
1047			pr_err("SELinux: error reading MLS range of context\n");
1048			goto out;
1049		}
1050	}
1051
1052	rc = -EINVAL;
1053	if (!policydb_context_isvalid(p, c)) {
1054		pr_err("SELinux:  invalid security context\n");
1055		context_destroy(c);
1056		goto out;
1057	}
1058	rc = 0;
1059out:
1060	return rc;
1061}
1062
1063/*
1064 * The following *_read functions are used to
1065 * read the symbol data from a policy database
1066 * binary representation file.
1067 */
1068
1069static int str_read(char **strp, gfp_t flags, void *fp, u32 len)
1070{
1071	int rc;
1072	char *str;
1073
1074	if ((len == 0) || (len == (u32)-1))
1075		return -EINVAL;
1076
1077	str = kmalloc(len + 1, flags | __GFP_NOWARN);
1078	if (!str)
1079		return -ENOMEM;
1080
1081	rc = next_entry(str, fp, len);
1082	if (rc) {
1083		kfree(str);
1084		return rc;
1085	}
1086
1087	str[len] = '\0';
1088	*strp = str;
1089	return 0;
1090}
1091
1092static int perm_read(struct policydb *p, struct symtab *s, void *fp)
1093{
1094	char *key = NULL;
1095	struct perm_datum *perdatum;
1096	int rc;
1097	__le32 buf[2];
1098	u32 len;
1099
 
1100	perdatum = kzalloc(sizeof(*perdatum), GFP_KERNEL);
1101	if (!perdatum)
1102		return -ENOMEM;
1103
1104	rc = next_entry(buf, fp, sizeof buf);
1105	if (rc)
1106		goto bad;
1107
1108	len = le32_to_cpu(buf[0]);
1109	perdatum->value = le32_to_cpu(buf[1]);
1110
1111	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
 
1112	if (rc)
1113		goto bad;
 
1114
1115	rc = symtab_insert(s, key, perdatum);
1116	if (rc)
1117		goto bad;
1118
1119	return 0;
1120bad:
1121	perm_destroy(key, perdatum, NULL);
1122	return rc;
1123}
1124
1125static int common_read(struct policydb *p, struct symtab *s, void *fp)
1126{
1127	char *key = NULL;
1128	struct common_datum *comdatum;
1129	__le32 buf[4];
1130	u32 len, nel;
1131	int i, rc;
1132
 
1133	comdatum = kzalloc(sizeof(*comdatum), GFP_KERNEL);
1134	if (!comdatum)
1135		return -ENOMEM;
1136
1137	rc = next_entry(buf, fp, sizeof buf);
1138	if (rc)
1139		goto bad;
1140
1141	len = le32_to_cpu(buf[0]);
1142	comdatum->value = le32_to_cpu(buf[1]);
1143	nel = le32_to_cpu(buf[3]);
1144
1145	rc = symtab_init(&comdatum->permissions, nel);
1146	if (rc)
1147		goto bad;
1148	comdatum->permissions.nprim = le32_to_cpu(buf[2]);
 
1149
1150	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
 
1151	if (rc)
1152		goto bad;
 
1153
1154	for (i = 0; i < nel; i++) {
1155		rc = perm_read(p, &comdatum->permissions, fp);
1156		if (rc)
1157			goto bad;
1158	}
1159
1160	rc = symtab_insert(s, key, comdatum);
1161	if (rc)
1162		goto bad;
1163	return 0;
1164bad:
1165	common_destroy(key, comdatum, NULL);
1166	return rc;
1167}
1168
1169static void type_set_init(struct type_set *t)
1170{
1171	ebitmap_init(&t->types);
1172	ebitmap_init(&t->negset);
1173}
1174
1175static int type_set_read(struct type_set *t, void *fp)
1176{
1177	__le32 buf[1];
1178	int rc;
1179
1180	if (ebitmap_read(&t->types, fp))
1181		return -EINVAL;
1182	if (ebitmap_read(&t->negset, fp))
1183		return -EINVAL;
1184
1185	rc = next_entry(buf, fp, sizeof(u32));
1186	if (rc < 0)
1187		return -EINVAL;
1188	t->flags = le32_to_cpu(buf[0]);
1189
1190	return 0;
1191}
1192
1193
1194static int read_cons_helper(struct policydb *p,
1195				struct constraint_node **nodep,
1196				int ncons, int allowxtarget, void *fp)
1197{
1198	struct constraint_node *c, *lc;
1199	struct constraint_expr *e, *le;
1200	__le32 buf[3];
1201	u32 nexpr;
1202	int rc, i, j, depth;
1203
1204	lc = NULL;
1205	for (i = 0; i < ncons; i++) {
1206		c = kzalloc(sizeof(*c), GFP_KERNEL);
1207		if (!c)
1208			return -ENOMEM;
1209
1210		if (lc)
1211			lc->next = c;
1212		else
1213			*nodep = c;
1214
1215		rc = next_entry(buf, fp, (sizeof(u32) * 2));
1216		if (rc)
1217			return rc;
1218		c->permissions = le32_to_cpu(buf[0]);
1219		nexpr = le32_to_cpu(buf[1]);
1220		le = NULL;
1221		depth = -1;
1222		for (j = 0; j < nexpr; j++) {
1223			e = kzalloc(sizeof(*e), GFP_KERNEL);
1224			if (!e)
1225				return -ENOMEM;
1226
1227			if (le)
1228				le->next = e;
1229			else
1230				c->expr = e;
1231
1232			rc = next_entry(buf, fp, (sizeof(u32) * 3));
1233			if (rc)
1234				return rc;
1235			e->expr_type = le32_to_cpu(buf[0]);
1236			e->attr = le32_to_cpu(buf[1]);
1237			e->op = le32_to_cpu(buf[2]);
1238
1239			switch (e->expr_type) {
1240			case CEXPR_NOT:
1241				if (depth < 0)
1242					return -EINVAL;
1243				break;
1244			case CEXPR_AND:
1245			case CEXPR_OR:
1246				if (depth < 1)
1247					return -EINVAL;
1248				depth--;
1249				break;
1250			case CEXPR_ATTR:
1251				if (depth == (CEXPR_MAXDEPTH - 1))
1252					return -EINVAL;
1253				depth++;
1254				break;
1255			case CEXPR_NAMES:
1256				if (!allowxtarget && (e->attr & CEXPR_XTARGET))
1257					return -EINVAL;
1258				if (depth == (CEXPR_MAXDEPTH - 1))
1259					return -EINVAL;
1260				depth++;
1261				rc = ebitmap_read(&e->names, fp);
1262				if (rc)
1263					return rc;
1264				if (p->policyvers >=
1265				    POLICYDB_VERSION_CONSTRAINT_NAMES) {
1266					e->type_names = kzalloc(sizeof
1267						(*e->type_names), GFP_KERNEL);
 
1268					if (!e->type_names)
1269						return -ENOMEM;
1270					type_set_init(e->type_names);
1271					rc = type_set_read(e->type_names, fp);
1272					if (rc)
1273						return rc;
1274				}
1275				break;
1276			default:
1277				return -EINVAL;
1278			}
1279			le = e;
1280		}
1281		if (depth != 0)
1282			return -EINVAL;
1283		lc = c;
1284	}
1285
1286	return 0;
1287}
1288
1289static int class_read(struct policydb *p, struct symtab *s, void *fp)
1290{
1291	char *key = NULL;
1292	struct class_datum *cladatum;
1293	__le32 buf[6];
1294	u32 len, len2, ncons, nel;
1295	int i, rc;
1296
 
1297	cladatum = kzalloc(sizeof(*cladatum), GFP_KERNEL);
1298	if (!cladatum)
1299		return -ENOMEM;
1300
1301	rc = next_entry(buf, fp, sizeof(u32)*6);
1302	if (rc)
1303		goto bad;
1304
1305	len = le32_to_cpu(buf[0]);
1306	len2 = le32_to_cpu(buf[1]);
1307	cladatum->value = le32_to_cpu(buf[2]);
1308	nel = le32_to_cpu(buf[4]);
1309
1310	rc = symtab_init(&cladatum->permissions, nel);
1311	if (rc)
1312		goto bad;
1313	cladatum->permissions.nprim = le32_to_cpu(buf[3]);
 
1314
1315	ncons = le32_to_cpu(buf[5]);
1316
1317	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
 
1318	if (rc)
1319		goto bad;
 
1320
1321	if (len2) {
1322		rc = str_read(&cladatum->comkey, GFP_KERNEL, fp, len2);
 
 
 
 
1323		if (rc)
1324			goto bad;
 
1325
1326		rc = -EINVAL;
1327		cladatum->comdatum = symtab_search(&p->p_commons,
1328						   cladatum->comkey);
1329		if (!cladatum->comdatum) {
1330			pr_err("SELinux:  unknown common %s\n",
1331			       cladatum->comkey);
1332			goto bad;
1333		}
1334	}
1335	for (i = 0; i < nel; i++) {
1336		rc = perm_read(p, &cladatum->permissions, fp);
1337		if (rc)
1338			goto bad;
1339	}
1340
1341	rc = read_cons_helper(p, &cladatum->constraints, ncons, 0, fp);
1342	if (rc)
1343		goto bad;
1344
1345	if (p->policyvers >= POLICYDB_VERSION_VALIDATETRANS) {
1346		/* grab the validatetrans rules */
1347		rc = next_entry(buf, fp, sizeof(u32));
1348		if (rc)
1349			goto bad;
1350		ncons = le32_to_cpu(buf[0]);
1351		rc = read_cons_helper(p, &cladatum->validatetrans,
1352				ncons, 1, fp);
1353		if (rc)
1354			goto bad;
1355	}
1356
1357	if (p->policyvers >= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS) {
1358		rc = next_entry(buf, fp, sizeof(u32) * 3);
1359		if (rc)
1360			goto bad;
1361
1362		cladatum->default_user = le32_to_cpu(buf[0]);
1363		cladatum->default_role = le32_to_cpu(buf[1]);
1364		cladatum->default_range = le32_to_cpu(buf[2]);
1365	}
1366
1367	if (p->policyvers >= POLICYDB_VERSION_DEFAULT_TYPE) {
1368		rc = next_entry(buf, fp, sizeof(u32) * 1);
1369		if (rc)
1370			goto bad;
1371		cladatum->default_type = le32_to_cpu(buf[0]);
1372	}
1373
1374	rc = symtab_insert(s, key, cladatum);
1375	if (rc)
1376		goto bad;
1377
1378	return 0;
1379bad:
1380	cls_destroy(key, cladatum, NULL);
1381	return rc;
1382}
1383
1384static int role_read(struct policydb *p, struct symtab *s, void *fp)
1385{
1386	char *key = NULL;
1387	struct role_datum *role;
1388	int rc, to_read = 2;
1389	__le32 buf[3];
1390	u32 len;
1391
 
1392	role = kzalloc(sizeof(*role), GFP_KERNEL);
1393	if (!role)
1394		return -ENOMEM;
1395
1396	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1397		to_read = 3;
1398
1399	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1400	if (rc)
1401		goto bad;
1402
1403	len = le32_to_cpu(buf[0]);
1404	role->value = le32_to_cpu(buf[1]);
1405	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1406		role->bounds = le32_to_cpu(buf[2]);
1407
1408	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
 
1409	if (rc)
1410		goto bad;
 
1411
1412	rc = ebitmap_read(&role->dominates, fp);
1413	if (rc)
1414		goto bad;
1415
1416	rc = ebitmap_read(&role->types, fp);
1417	if (rc)
1418		goto bad;
1419
1420	if (strcmp(key, OBJECT_R) == 0) {
1421		rc = -EINVAL;
1422		if (role->value != OBJECT_R_VAL) {
1423			pr_err("SELinux: Role %s has wrong value %d\n",
1424			       OBJECT_R, role->value);
1425			goto bad;
1426		}
1427		rc = 0;
1428		goto bad;
1429	}
1430
1431	rc = symtab_insert(s, key, role);
1432	if (rc)
1433		goto bad;
1434	return 0;
1435bad:
1436	role_destroy(key, role, NULL);
1437	return rc;
1438}
1439
1440static int type_read(struct policydb *p, struct symtab *s, void *fp)
1441{
1442	char *key = NULL;
1443	struct type_datum *typdatum;
1444	int rc, to_read = 3;
1445	__le32 buf[4];
1446	u32 len;
1447
 
1448	typdatum = kzalloc(sizeof(*typdatum), GFP_KERNEL);
1449	if (!typdatum)
1450		return -ENOMEM;
1451
1452	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1453		to_read = 4;
1454
1455	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1456	if (rc)
1457		goto bad;
1458
1459	len = le32_to_cpu(buf[0]);
1460	typdatum->value = le32_to_cpu(buf[1]);
1461	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) {
1462		u32 prop = le32_to_cpu(buf[2]);
1463
1464		if (prop & TYPEDATUM_PROPERTY_PRIMARY)
1465			typdatum->primary = 1;
1466		if (prop & TYPEDATUM_PROPERTY_ATTRIBUTE)
1467			typdatum->attribute = 1;
1468
1469		typdatum->bounds = le32_to_cpu(buf[3]);
1470	} else {
1471		typdatum->primary = le32_to_cpu(buf[2]);
1472	}
1473
1474	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
1475	if (rc)
1476		goto bad;
 
1477
1478	rc = symtab_insert(s, key, typdatum);
1479	if (rc)
1480		goto bad;
1481	return 0;
1482bad:
1483	type_destroy(key, typdatum, NULL);
1484	return rc;
1485}
1486
1487
1488/*
1489 * Read a MLS level structure from a policydb binary
1490 * representation file.
1491 */
1492static int mls_read_level(struct mls_level *lp, void *fp)
1493{
1494	__le32 buf[1];
1495	int rc;
1496
1497	memset(lp, 0, sizeof(*lp));
1498
1499	rc = next_entry(buf, fp, sizeof buf);
1500	if (rc) {
1501		pr_err("SELinux: mls: truncated level\n");
1502		return rc;
1503	}
1504	lp->sens = le32_to_cpu(buf[0]);
1505
1506	rc = ebitmap_read(&lp->cat, fp);
1507	if (rc) {
1508		pr_err("SELinux: mls:  error reading level categories\n");
1509		return rc;
1510	}
1511	return 0;
1512}
1513
1514static int user_read(struct policydb *p, struct symtab *s, void *fp)
1515{
1516	char *key = NULL;
1517	struct user_datum *usrdatum;
1518	int rc, to_read = 2;
1519	__le32 buf[3];
1520	u32 len;
1521
 
1522	usrdatum = kzalloc(sizeof(*usrdatum), GFP_KERNEL);
1523	if (!usrdatum)
1524		return -ENOMEM;
1525
1526	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1527		to_read = 3;
1528
1529	rc = next_entry(buf, fp, sizeof(buf[0]) * to_read);
1530	if (rc)
1531		goto bad;
1532
1533	len = le32_to_cpu(buf[0]);
1534	usrdatum->value = le32_to_cpu(buf[1]);
1535	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
1536		usrdatum->bounds = le32_to_cpu(buf[2]);
1537
1538	rc = str_read(&key, GFP_KERNEL, fp, len);
 
 
 
 
1539	if (rc)
1540		goto bad;
 
1541
1542	rc = ebitmap_read(&usrdatum->roles, fp);
1543	if (rc)
1544		goto bad;
1545
1546	if (p->policyvers >= POLICYDB_VERSION_MLS) {
1547		rc = mls_read_range_helper(&usrdatum->range, fp);
1548		if (rc)
1549			goto bad;
1550		rc = mls_read_level(&usrdatum->dfltlevel, fp);
1551		if (rc)
1552			goto bad;
1553	}
1554
1555	rc = symtab_insert(s, key, usrdatum);
1556	if (rc)
1557		goto bad;
1558	return 0;
1559bad:
1560	user_destroy(key, usrdatum, NULL);
1561	return rc;
1562}
1563
1564static int sens_read(struct policydb *p, struct symtab *s, void *fp)
1565{
1566	char *key = NULL;
1567	struct level_datum *levdatum;
1568	int rc;
1569	__le32 buf[2];
1570	u32 len;
1571
 
1572	levdatum = kzalloc(sizeof(*levdatum), GFP_ATOMIC);
1573	if (!levdatum)
1574		return -ENOMEM;
1575
1576	rc = next_entry(buf, fp, sizeof buf);
1577	if (rc)
1578		goto bad;
1579
1580	len = le32_to_cpu(buf[0]);
1581	levdatum->isalias = le32_to_cpu(buf[1]);
1582
1583	rc = str_read(&key, GFP_ATOMIC, fp, len);
 
 
 
 
1584	if (rc)
1585		goto bad;
 
1586
1587	rc = -ENOMEM;
1588	levdatum->level = kmalloc(sizeof(*levdatum->level), GFP_ATOMIC);
1589	if (!levdatum->level)
1590		goto bad;
1591
1592	rc = mls_read_level(levdatum->level, fp);
1593	if (rc)
1594		goto bad;
1595
1596	rc = symtab_insert(s, key, levdatum);
1597	if (rc)
1598		goto bad;
1599	return 0;
1600bad:
1601	sens_destroy(key, levdatum, NULL);
1602	return rc;
1603}
1604
1605static int cat_read(struct policydb *p, struct symtab *s, void *fp)
1606{
1607	char *key = NULL;
1608	struct cat_datum *catdatum;
1609	int rc;
1610	__le32 buf[3];
1611	u32 len;
1612
 
1613	catdatum = kzalloc(sizeof(*catdatum), GFP_ATOMIC);
1614	if (!catdatum)
1615		return -ENOMEM;
1616
1617	rc = next_entry(buf, fp, sizeof buf);
1618	if (rc)
1619		goto bad;
1620
1621	len = le32_to_cpu(buf[0]);
1622	catdatum->value = le32_to_cpu(buf[1]);
1623	catdatum->isalias = le32_to_cpu(buf[2]);
1624
1625	rc = str_read(&key, GFP_ATOMIC, fp, len);
 
 
 
 
1626	if (rc)
1627		goto bad;
 
1628
1629	rc = symtab_insert(s, key, catdatum);
1630	if (rc)
1631		goto bad;
1632	return 0;
1633bad:
1634	cat_destroy(key, catdatum, NULL);
1635	return rc;
1636}
1637
1638static int (*const read_f[SYM_NUM]) (struct policydb *p,
1639				     struct symtab *s, void *fp) = {
1640	common_read,
1641	class_read,
1642	role_read,
1643	type_read,
1644	user_read,
1645	cond_read_bool,
1646	sens_read,
1647	cat_read,
1648};
1649
1650static int user_bounds_sanity_check(void *key, void *datum, void *datap)
1651{
1652	struct user_datum *upper, *user;
1653	struct policydb *p = datap;
1654	int depth = 0;
1655
1656	upper = user = datum;
1657	while (upper->bounds) {
1658		struct ebitmap_node *node;
1659		unsigned long bit;
1660
1661		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1662			pr_err("SELinux: user %s: "
1663			       "too deep or looped boundary",
1664			       (char *) key);
1665			return -EINVAL;
1666		}
1667
1668		upper = p->user_val_to_struct[upper->bounds - 1];
1669		ebitmap_for_each_positive_bit(&user->roles, node, bit) {
1670			if (ebitmap_get_bit(&upper->roles, bit))
1671				continue;
1672
1673			pr_err("SELinux: boundary violated policy: "
 
1674			       "user=%s role=%s bounds=%s\n",
1675			       sym_name(p, SYM_USERS, user->value - 1),
1676			       sym_name(p, SYM_ROLES, bit),
1677			       sym_name(p, SYM_USERS, upper->value - 1));
1678
1679			return -EINVAL;
1680		}
1681	}
1682
1683	return 0;
1684}
1685
1686static int role_bounds_sanity_check(void *key, void *datum, void *datap)
1687{
1688	struct role_datum *upper, *role;
1689	struct policydb *p = datap;
1690	int depth = 0;
1691
1692	upper = role = datum;
1693	while (upper->bounds) {
1694		struct ebitmap_node *node;
1695		unsigned long bit;
1696
1697		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1698			pr_err("SELinux: role %s: "
1699			       "too deep or looped bounds\n",
1700			       (char *) key);
1701			return -EINVAL;
1702		}
1703
1704		upper = p->role_val_to_struct[upper->bounds - 1];
1705		ebitmap_for_each_positive_bit(&role->types, node, bit) {
1706			if (ebitmap_get_bit(&upper->types, bit))
1707				continue;
1708
1709			pr_err("SELinux: boundary violated policy: "
 
1710			       "role=%s type=%s bounds=%s\n",
1711			       sym_name(p, SYM_ROLES, role->value - 1),
1712			       sym_name(p, SYM_TYPES, bit),
1713			       sym_name(p, SYM_ROLES, upper->value - 1));
1714
1715			return -EINVAL;
1716		}
1717	}
1718
1719	return 0;
1720}
1721
1722static int type_bounds_sanity_check(void *key, void *datum, void *datap)
1723{
1724	struct type_datum *upper;
1725	struct policydb *p = datap;
1726	int depth = 0;
1727
1728	upper = datum;
1729	while (upper->bounds) {
1730		if (++depth == POLICYDB_BOUNDS_MAXDEPTH) {
1731			pr_err("SELinux: type %s: "
1732			       "too deep or looped boundary\n",
1733			       (char *) key);
1734			return -EINVAL;
1735		}
1736
1737		upper = p->type_val_to_struct[upper->bounds - 1];
 
1738		BUG_ON(!upper);
1739
1740		if (upper->attribute) {
1741			pr_err("SELinux: type %s: "
1742			       "bounded by attribute %s",
1743			       (char *) key,
1744			       sym_name(p, SYM_TYPES, upper->value - 1));
1745			return -EINVAL;
1746		}
1747	}
1748
1749	return 0;
1750}
1751
1752static int policydb_bounds_sanity_check(struct policydb *p)
1753{
1754	int rc;
1755
1756	if (p->policyvers < POLICYDB_VERSION_BOUNDARY)
1757		return 0;
1758
1759	rc = hashtab_map(&p->p_users.table, user_bounds_sanity_check, p);
 
1760	if (rc)
1761		return rc;
1762
1763	rc = hashtab_map(&p->p_roles.table, role_bounds_sanity_check, p);
 
1764	if (rc)
1765		return rc;
1766
1767	rc = hashtab_map(&p->p_types.table, type_bounds_sanity_check, p);
 
1768	if (rc)
1769		return rc;
1770
1771	return 0;
1772}
1773
1774u16 string_to_security_class(struct policydb *p, const char *name)
1775{
1776	struct class_datum *cladatum;
1777
1778	cladatum = symtab_search(&p->p_classes, name);
1779	if (!cladatum)
1780		return 0;
1781
1782	return cladatum->value;
1783}
1784
1785u32 string_to_av_perm(struct policydb *p, u16 tclass, const char *name)
1786{
1787	struct class_datum *cladatum;
1788	struct perm_datum *perdatum = NULL;
1789	struct common_datum *comdatum;
1790
1791	if (!tclass || tclass > p->p_classes.nprim)
1792		return 0;
1793
1794	cladatum = p->class_val_to_struct[tclass-1];
1795	comdatum = cladatum->comdatum;
1796	if (comdatum)
1797		perdatum = symtab_search(&comdatum->permissions, name);
 
1798	if (!perdatum)
1799		perdatum = symtab_search(&cladatum->permissions, name);
 
1800	if (!perdatum)
1801		return 0;
1802
1803	return 1U << (perdatum->value-1);
1804}
1805
1806static int range_read(struct policydb *p, void *fp)
1807{
1808	struct range_trans *rt = NULL;
1809	struct mls_range *r = NULL;
1810	int i, rc;
1811	__le32 buf[2];
1812	u32 nel;
1813
1814	if (p->policyvers < POLICYDB_VERSION_MLS)
1815		return 0;
1816
1817	rc = next_entry(buf, fp, sizeof(u32));
1818	if (rc)
1819		return rc;
1820
1821	nel = le32_to_cpu(buf[0]);
1822
1823	rc = hashtab_init(&p->range_tr, nel);
1824	if (rc)
1825		return rc;
1826
1827	for (i = 0; i < nel; i++) {
1828		rc = -ENOMEM;
1829		rt = kzalloc(sizeof(*rt), GFP_KERNEL);
1830		if (!rt)
1831			goto out;
1832
1833		rc = next_entry(buf, fp, (sizeof(u32) * 2));
1834		if (rc)
1835			goto out;
1836
1837		rt->source_type = le32_to_cpu(buf[0]);
1838		rt->target_type = le32_to_cpu(buf[1]);
1839		if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) {
1840			rc = next_entry(buf, fp, sizeof(u32));
1841			if (rc)
1842				goto out;
1843			rt->target_class = le32_to_cpu(buf[0]);
1844		} else
1845			rt->target_class = p->process_class;
1846
1847		rc = -EINVAL;
1848		if (!policydb_type_isvalid(p, rt->source_type) ||
1849		    !policydb_type_isvalid(p, rt->target_type) ||
1850		    !policydb_class_isvalid(p, rt->target_class))
1851			goto out;
1852
1853		rc = -ENOMEM;
1854		r = kzalloc(sizeof(*r), GFP_KERNEL);
1855		if (!r)
1856			goto out;
1857
1858		rc = mls_read_range_helper(r, fp);
1859		if (rc)
1860			goto out;
1861
1862		rc = -EINVAL;
1863		if (!mls_range_isvalid(p, r)) {
1864			pr_warn("SELinux:  rangetrans:  invalid range\n");
1865			goto out;
1866		}
1867
1868		rc = hashtab_insert(&p->range_tr, rt, r, rangetr_key_params);
1869		if (rc)
1870			goto out;
1871
1872		rt = NULL;
1873		r = NULL;
1874	}
1875	hash_eval(&p->range_tr, "rangetr");
1876	rc = 0;
1877out:
1878	kfree(rt);
1879	kfree(r);
1880	return rc;
1881}
1882
1883static int filename_trans_read_helper_compat(struct policydb *p, void *fp)
1884{
1885	struct filename_trans_key key, *ft = NULL;
1886	struct filename_trans_datum *last, *datum = NULL;
1887	char *name = NULL;
1888	u32 len, stype, otype;
1889	__le32 buf[4];
1890	int rc;
1891
1892	/* length of the path component string */
1893	rc = next_entry(buf, fp, sizeof(u32));
1894	if (rc)
1895		return rc;
1896	len = le32_to_cpu(buf[0]);
1897
1898	/* path component string */
1899	rc = str_read(&name, GFP_KERNEL, fp, len);
1900	if (rc)
1901		return rc;
 
1902
1903	rc = next_entry(buf, fp, sizeof(u32) * 4);
1904	if (rc)
1905		goto out;
1906
1907	stype = le32_to_cpu(buf[0]);
1908	key.ttype = le32_to_cpu(buf[1]);
1909	key.tclass = le32_to_cpu(buf[2]);
1910	key.name = name;
1911
1912	otype = le32_to_cpu(buf[3]);
1913
1914	last = NULL;
1915	datum = policydb_filenametr_search(p, &key);
1916	while (datum) {
1917		if (unlikely(ebitmap_get_bit(&datum->stypes, stype - 1))) {
1918			/* conflicting/duplicate rules are ignored */
1919			datum = NULL;
1920			goto out;
1921		}
1922		if (likely(datum->otype == otype))
1923			break;
1924		last = datum;
1925		datum = datum->next;
1926	}
1927	if (!datum) {
1928		rc = -ENOMEM;
1929		datum = kmalloc(sizeof(*datum), GFP_KERNEL);
1930		if (!datum)
1931			goto out;
1932
1933		ebitmap_init(&datum->stypes);
1934		datum->otype = otype;
1935		datum->next = NULL;
1936
1937		if (unlikely(last)) {
1938			last->next = datum;
1939		} else {
1940			rc = -ENOMEM;
1941			ft = kmemdup(&key, sizeof(key), GFP_KERNEL);
1942			if (!ft)
1943				goto out;
1944
1945			rc = hashtab_insert(&p->filename_trans, ft, datum,
1946					    filenametr_key_params);
1947			if (rc)
1948				goto out;
1949			name = NULL;
1950
1951			rc = ebitmap_set_bit(&p->filename_trans_ttypes,
1952					     key.ttype, 1);
1953			if (rc)
1954				return rc;
1955		}
1956	}
1957	kfree(name);
1958	return ebitmap_set_bit(&datum->stypes, stype - 1, 1);
1959
1960out:
1961	kfree(ft);
1962	kfree(name);
1963	kfree(datum);
1964	return rc;
1965}
1966
1967static int filename_trans_read_helper(struct policydb *p, void *fp)
1968{
1969	struct filename_trans_key *ft = NULL;
1970	struct filename_trans_datum **dst, *datum, *first = NULL;
1971	char *name = NULL;
1972	u32 len, ttype, tclass, ndatum, i;
1973	__le32 buf[3];
1974	int rc;
1975
1976	/* length of the path component string */
1977	rc = next_entry(buf, fp, sizeof(u32));
1978	if (rc)
1979		return rc;
1980	len = le32_to_cpu(buf[0]);
1981
1982	/* path component string */
1983	rc = str_read(&name, GFP_KERNEL, fp, len);
1984	if (rc)
1985		return rc;
1986
1987	rc = next_entry(buf, fp, sizeof(u32) * 3);
1988	if (rc)
1989		goto out;
1990
1991	ttype = le32_to_cpu(buf[0]);
1992	tclass = le32_to_cpu(buf[1]);
1993
1994	ndatum = le32_to_cpu(buf[2]);
1995	if (ndatum == 0) {
1996		pr_err("SELinux:  Filename transition key with no datum\n");
1997		rc = -ENOENT;
1998		goto out;
1999	}
2000
2001	dst = &first;
2002	for (i = 0; i < ndatum; i++) {
2003		rc = -ENOMEM;
2004		datum = kmalloc(sizeof(*datum), GFP_KERNEL);
2005		if (!datum)
2006			goto out;
2007
2008		*dst = datum;
2009
2010		/* ebitmap_read() will at least init the bitmap */
2011		rc = ebitmap_read(&datum->stypes, fp);
2012		if (rc)
2013			goto out;
 
2014
2015		rc = next_entry(buf, fp, sizeof(u32));
2016		if (rc)
2017			goto out;
2018
2019		datum->otype = le32_to_cpu(buf[0]);
2020		datum->next = NULL;
2021
2022		dst = &datum->next;
2023	}
2024
2025	rc = -ENOMEM;
2026	ft = kmalloc(sizeof(*ft), GFP_KERNEL);
2027	if (!ft)
2028		goto out;
2029
2030	ft->ttype = ttype;
2031	ft->tclass = tclass;
2032	ft->name = name;
2033
2034	rc = hashtab_insert(&p->filename_trans, ft, first,
2035			    filenametr_key_params);
2036	if (rc == -EEXIST)
2037		pr_err("SELinux:  Duplicate filename transition key\n");
2038	if (rc)
2039		goto out;
2040
2041	return ebitmap_set_bit(&p->filename_trans_ttypes, ttype, 1);
 
 
2042
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2043out:
2044	kfree(ft);
2045	kfree(name);
2046	while (first) {
2047		datum = first;
2048		first = first->next;
2049
2050		ebitmap_destroy(&datum->stypes);
2051		kfree(datum);
2052	}
2053	return rc;
2054}
2055
2056static int filename_trans_read(struct policydb *p, void *fp)
2057{
2058	u32 nel;
2059	__le32 buf[1];
2060	int rc, i;
2061
2062	if (p->policyvers < POLICYDB_VERSION_FILENAME_TRANS)
2063		return 0;
2064
2065	rc = next_entry(buf, fp, sizeof(u32));
2066	if (rc)
2067		return rc;
2068	nel = le32_to_cpu(buf[0]);
2069
2070	if (p->policyvers < POLICYDB_VERSION_COMP_FTRANS) {
2071		p->compat_filename_trans_count = nel;
2072
2073		rc = hashtab_init(&p->filename_trans, (1 << 11));
2074		if (rc)
2075			return rc;
2076
2077		for (i = 0; i < nel; i++) {
2078			rc = filename_trans_read_helper_compat(p, fp);
2079			if (rc)
2080				return rc;
2081		}
2082	} else {
2083		rc = hashtab_init(&p->filename_trans, nel);
2084		if (rc)
2085			return rc;
2086
2087		for (i = 0; i < nel; i++) {
2088			rc = filename_trans_read_helper(p, fp);
2089			if (rc)
2090				return rc;
2091		}
2092	}
2093	hash_eval(&p->filename_trans, "filenametr");
2094	return 0;
2095}
2096
2097static int genfs_read(struct policydb *p, void *fp)
2098{
2099	int i, j, rc;
2100	u32 nel, nel2, len, len2;
2101	__le32 buf[1];
2102	struct ocontext *l, *c;
2103	struct ocontext *newc = NULL;
2104	struct genfs *genfs_p, *genfs;
2105	struct genfs *newgenfs = NULL;
2106
2107	rc = next_entry(buf, fp, sizeof(u32));
2108	if (rc)
2109		return rc;
2110	nel = le32_to_cpu(buf[0]);
2111
2112	for (i = 0; i < nel; i++) {
2113		rc = next_entry(buf, fp, sizeof(u32));
2114		if (rc)
2115			goto out;
2116		len = le32_to_cpu(buf[0]);
2117
2118		rc = -ENOMEM;
2119		newgenfs = kzalloc(sizeof(*newgenfs), GFP_KERNEL);
2120		if (!newgenfs)
2121			goto out;
2122
2123		rc = str_read(&newgenfs->fstype, GFP_KERNEL, fp, len);
 
 
 
 
 
2124		if (rc)
2125			goto out;
2126
 
 
2127		for (genfs_p = NULL, genfs = p->genfs; genfs;
2128		     genfs_p = genfs, genfs = genfs->next) {
2129			rc = -EINVAL;
2130			if (strcmp(newgenfs->fstype, genfs->fstype) == 0) {
2131				pr_err("SELinux:  dup genfs fstype %s\n",
2132				       newgenfs->fstype);
2133				goto out;
2134			}
2135			if (strcmp(newgenfs->fstype, genfs->fstype) < 0)
2136				break;
2137		}
2138		newgenfs->next = genfs;
2139		if (genfs_p)
2140			genfs_p->next = newgenfs;
2141		else
2142			p->genfs = newgenfs;
2143		genfs = newgenfs;
2144		newgenfs = NULL;
2145
2146		rc = next_entry(buf, fp, sizeof(u32));
2147		if (rc)
2148			goto out;
2149
2150		nel2 = le32_to_cpu(buf[0]);
2151		for (j = 0; j < nel2; j++) {
2152			rc = next_entry(buf, fp, sizeof(u32));
2153			if (rc)
2154				goto out;
2155			len = le32_to_cpu(buf[0]);
2156
2157			rc = -ENOMEM;
2158			newc = kzalloc(sizeof(*newc), GFP_KERNEL);
2159			if (!newc)
2160				goto out;
2161
2162			rc = str_read(&newc->u.name, GFP_KERNEL, fp, len);
 
 
 
 
 
2163			if (rc)
2164				goto out;
 
2165
2166			rc = next_entry(buf, fp, sizeof(u32));
2167			if (rc)
2168				goto out;
2169
2170			newc->v.sclass = le32_to_cpu(buf[0]);
2171			rc = context_read_and_validate(&newc->context[0], p, fp);
2172			if (rc)
2173				goto out;
2174
2175			for (l = NULL, c = genfs->head; c;
2176			     l = c, c = c->next) {
2177				rc = -EINVAL;
2178				if (!strcmp(newc->u.name, c->u.name) &&
2179				    (!c->v.sclass || !newc->v.sclass ||
2180				     newc->v.sclass == c->v.sclass)) {
2181					pr_err("SELinux:  dup genfs entry (%s,%s)\n",
2182					       genfs->fstype, c->u.name);
2183					goto out;
2184				}
2185				len = strlen(newc->u.name);
2186				len2 = strlen(c->u.name);
2187				if (len > len2)
2188					break;
2189			}
2190
2191			newc->next = c;
2192			if (l)
2193				l->next = newc;
2194			else
2195				genfs->head = newc;
2196			newc = NULL;
2197		}
2198	}
2199	rc = 0;
2200out:
2201	if (newgenfs) {
2202		kfree(newgenfs->fstype);
2203		kfree(newgenfs);
2204	}
2205	ocontext_destroy(newc, OCON_FSUSE);
2206
2207	return rc;
2208}
2209
2210static int ocontext_read(struct policydb *p, const struct policydb_compat_info *info,
2211			 void *fp)
2212{
2213	int i, j, rc;
2214	u32 nel, len;
2215	__be64 prefixbuf[1];
2216	__le32 buf[3];
2217	struct ocontext *l, *c;
2218	u32 nodebuf[8];
2219
2220	for (i = 0; i < info->ocon_num; i++) {
2221		rc = next_entry(buf, fp, sizeof(u32));
2222		if (rc)
2223			goto out;
2224		nel = le32_to_cpu(buf[0]);
2225
2226		l = NULL;
2227		for (j = 0; j < nel; j++) {
2228			rc = -ENOMEM;
2229			c = kzalloc(sizeof(*c), GFP_KERNEL);
2230			if (!c)
2231				goto out;
2232			if (l)
2233				l->next = c;
2234			else
2235				p->ocontexts[i] = c;
2236			l = c;
2237
2238			switch (i) {
2239			case OCON_ISID:
2240				rc = next_entry(buf, fp, sizeof(u32));
2241				if (rc)
2242					goto out;
2243
2244				c->sid[0] = le32_to_cpu(buf[0]);
2245				rc = context_read_and_validate(&c->context[0], p, fp);
2246				if (rc)
2247					goto out;
2248				break;
2249			case OCON_FS:
2250			case OCON_NETIF:
2251				rc = next_entry(buf, fp, sizeof(u32));
2252				if (rc)
2253					goto out;
2254				len = le32_to_cpu(buf[0]);
2255
2256				rc = str_read(&c->u.name, GFP_KERNEL, fp, len);
 
 
 
 
 
2257				if (rc)
2258					goto out;
2259
 
2260				rc = context_read_and_validate(&c->context[0], p, fp);
2261				if (rc)
2262					goto out;
2263				rc = context_read_and_validate(&c->context[1], p, fp);
2264				if (rc)
2265					goto out;
2266				break;
2267			case OCON_PORT:
2268				rc = next_entry(buf, fp, sizeof(u32)*3);
2269				if (rc)
2270					goto out;
2271				c->u.port.protocol = le32_to_cpu(buf[0]);
2272				c->u.port.low_port = le32_to_cpu(buf[1]);
2273				c->u.port.high_port = le32_to_cpu(buf[2]);
2274				rc = context_read_and_validate(&c->context[0], p, fp);
2275				if (rc)
2276					goto out;
2277				break;
2278			case OCON_NODE:
2279				rc = next_entry(nodebuf, fp, sizeof(u32) * 2);
2280				if (rc)
2281					goto out;
2282				c->u.node.addr = nodebuf[0]; /* network order */
2283				c->u.node.mask = nodebuf[1]; /* network order */
2284				rc = context_read_and_validate(&c->context[0], p, fp);
2285				if (rc)
2286					goto out;
2287				break;
2288			case OCON_FSUSE:
2289				rc = next_entry(buf, fp, sizeof(u32)*2);
2290				if (rc)
2291					goto out;
2292
2293				rc = -EINVAL;
2294				c->v.behavior = le32_to_cpu(buf[0]);
2295				/* Determined at runtime, not in policy DB. */
2296				if (c->v.behavior == SECURITY_FS_USE_MNTPOINT)
2297					goto out;
2298				if (c->v.behavior > SECURITY_FS_USE_MAX)
2299					goto out;
2300
 
2301				len = le32_to_cpu(buf[1]);
2302				rc = str_read(&c->u.name, GFP_KERNEL, fp, len);
2303				if (rc)
2304					goto out;
2305
 
 
 
 
2306				rc = context_read_and_validate(&c->context[0], p, fp);
2307				if (rc)
2308					goto out;
2309				break;
2310			case OCON_NODE6: {
2311				int k;
2312
2313				rc = next_entry(nodebuf, fp, sizeof(u32) * 8);
2314				if (rc)
2315					goto out;
2316				for (k = 0; k < 4; k++)
2317					c->u.node6.addr[k] = nodebuf[k];
2318				for (k = 0; k < 4; k++)
2319					c->u.node6.mask[k] = nodebuf[k+4];
2320				rc = context_read_and_validate(&c->context[0], p, fp);
2321				if (rc)
2322					goto out;
2323				break;
2324			}
2325			case OCON_IBPKEY: {
2326				u32 pkey_lo, pkey_hi;
2327
2328				rc = next_entry(prefixbuf, fp, sizeof(u64));
2329				if (rc)
2330					goto out;
2331
2332				/* we need to have subnet_prefix in CPU order */
2333				c->u.ibpkey.subnet_prefix = be64_to_cpu(prefixbuf[0]);
2334
2335				rc = next_entry(buf, fp, sizeof(u32) * 2);
2336				if (rc)
2337					goto out;
2338
2339				pkey_lo = le32_to_cpu(buf[0]);
2340				pkey_hi = le32_to_cpu(buf[1]);
2341
2342				if (pkey_lo > U16_MAX || pkey_hi > U16_MAX) {
2343					rc = -EINVAL;
2344					goto out;
2345				}
2346
2347				c->u.ibpkey.low_pkey  = pkey_lo;
2348				c->u.ibpkey.high_pkey = pkey_hi;
2349
2350				rc = context_read_and_validate(&c->context[0],
2351							       p,
2352							       fp);
2353				if (rc)
2354					goto out;
2355				break;
2356			}
2357			case OCON_IBENDPORT: {
2358				u32 port;
2359
2360				rc = next_entry(buf, fp, sizeof(u32) * 2);
2361				if (rc)
2362					goto out;
2363				len = le32_to_cpu(buf[0]);
2364
2365				rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len);
2366				if (rc)
2367					goto out;
2368
2369				port = le32_to_cpu(buf[1]);
2370				if (port > U8_MAX || port == 0) {
2371					rc = -EINVAL;
2372					goto out;
2373				}
2374
2375				c->u.ibendport.port = port;
2376
2377				rc = context_read_and_validate(&c->context[0],
2378							       p,
2379							       fp);
2380				if (rc)
2381					goto out;
2382				break;
2383			} /* end case */
2384			} /* end switch */
2385		}
2386	}
2387	rc = 0;
2388out:
2389	return rc;
2390}
2391
2392/*
2393 * Read the configuration data from a policy database binary
2394 * representation file into a policy database structure.
2395 */
2396int policydb_read(struct policydb *p, void *fp)
2397{
2398	struct role_allow *ra, *lra;
2399	struct role_trans_key *rtk = NULL;
2400	struct role_trans_datum *rtd = NULL;
2401	int i, j, rc;
2402	__le32 buf[4];
2403	u32 len, nprim, nel, perm;
2404
2405	char *policydb_str;
2406	const struct policydb_compat_info *info;
2407
2408	policydb_init(p);
 
 
2409
2410	/* Read the magic number and string length. */
2411	rc = next_entry(buf, fp, sizeof(u32) * 2);
2412	if (rc)
2413		goto bad;
2414
2415	rc = -EINVAL;
2416	if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) {
2417		pr_err("SELinux:  policydb magic number 0x%x does "
2418		       "not match expected magic number 0x%x\n",
2419		       le32_to_cpu(buf[0]), POLICYDB_MAGIC);
2420		goto bad;
2421	}
2422
2423	rc = -EINVAL;
2424	len = le32_to_cpu(buf[1]);
2425	if (len != strlen(POLICYDB_STRING)) {
2426		pr_err("SELinux:  policydb string length %d does not "
2427		       "match expected length %zu\n",
2428		       len, strlen(POLICYDB_STRING));
2429		goto bad;
2430	}
2431
2432	rc = -ENOMEM;
2433	policydb_str = kmalloc(len + 1, GFP_KERNEL);
2434	if (!policydb_str) {
2435		pr_err("SELinux:  unable to allocate memory for policydb "
2436		       "string of length %d\n", len);
2437		goto bad;
2438	}
2439
2440	rc = next_entry(policydb_str, fp, len);
2441	if (rc) {
2442		pr_err("SELinux:  truncated policydb string identifier\n");
2443		kfree(policydb_str);
2444		goto bad;
2445	}
2446
2447	rc = -EINVAL;
2448	policydb_str[len] = '\0';
2449	if (strcmp(policydb_str, POLICYDB_STRING)) {
2450		pr_err("SELinux:  policydb string %s does not match "
2451		       "my string %s\n", policydb_str, POLICYDB_STRING);
2452		kfree(policydb_str);
2453		goto bad;
2454	}
2455	/* Done with policydb_str. */
2456	kfree(policydb_str);
2457	policydb_str = NULL;
2458
2459	/* Read the version and table sizes. */
2460	rc = next_entry(buf, fp, sizeof(u32)*4);
2461	if (rc)
2462		goto bad;
2463
2464	rc = -EINVAL;
2465	p->policyvers = le32_to_cpu(buf[0]);
2466	if (p->policyvers < POLICYDB_VERSION_MIN ||
2467	    p->policyvers > POLICYDB_VERSION_MAX) {
2468		pr_err("SELinux:  policydb version %d does not match "
2469		       "my version range %d-%d\n",
2470		       le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX);
2471		goto bad;
2472	}
2473
2474	if ((le32_to_cpu(buf[1]) & POLICYDB_CONFIG_MLS)) {
2475		p->mls_enabled = 1;
2476
2477		rc = -EINVAL;
2478		if (p->policyvers < POLICYDB_VERSION_MLS) {
2479			pr_err("SELinux: security policydb version %d "
2480				"(MLS) not backwards compatible\n",
2481				p->policyvers);
2482			goto bad;
2483		}
2484	}
2485	p->reject_unknown = !!(le32_to_cpu(buf[1]) & REJECT_UNKNOWN);
2486	p->allow_unknown = !!(le32_to_cpu(buf[1]) & ALLOW_UNKNOWN);
2487
2488	if (p->policyvers >= POLICYDB_VERSION_POLCAP) {
2489		rc = ebitmap_read(&p->policycaps, fp);
2490		if (rc)
2491			goto bad;
2492	}
2493
2494	if (p->policyvers >= POLICYDB_VERSION_PERMISSIVE) {
2495		rc = ebitmap_read(&p->permissive_map, fp);
2496		if (rc)
2497			goto bad;
2498	}
2499
2500	rc = -EINVAL;
2501	info = policydb_lookup_compat(p->policyvers);
2502	if (!info) {
2503		pr_err("SELinux:  unable to find policy compat info "
2504		       "for version %d\n", p->policyvers);
2505		goto bad;
2506	}
2507
2508	rc = -EINVAL;
2509	if (le32_to_cpu(buf[2]) != info->sym_num ||
2510		le32_to_cpu(buf[3]) != info->ocon_num) {
2511		pr_err("SELinux:  policydb table sizes (%d,%d) do "
2512		       "not match mine (%d,%d)\n", le32_to_cpu(buf[2]),
2513			le32_to_cpu(buf[3]),
2514		       info->sym_num, info->ocon_num);
2515		goto bad;
2516	}
2517
2518	for (i = 0; i < info->sym_num; i++) {
2519		rc = next_entry(buf, fp, sizeof(u32)*2);
2520		if (rc)
2521			goto bad;
2522		nprim = le32_to_cpu(buf[0]);
2523		nel = le32_to_cpu(buf[1]);
2524
2525		rc = symtab_init(&p->symtab[i], nel);
2526		if (rc)
2527			goto out;
2528
2529		if (i == SYM_ROLES) {
2530			rc = roles_init(p);
2531			if (rc)
2532				goto out;
2533		}
2534
2535		for (j = 0; j < nel; j++) {
2536			rc = read_f[i](p, &p->symtab[i], fp);
2537			if (rc)
2538				goto bad;
2539		}
2540
2541		p->symtab[i].nprim = nprim;
2542	}
2543
2544	rc = -EINVAL;
2545	p->process_class = string_to_security_class(p, "process");
2546	if (!p->process_class) {
2547		pr_err("SELinux: process class is required, not defined in policy\n");
2548		goto bad;
2549	}
2550
2551	rc = avtab_read(&p->te_avtab, fp, p);
2552	if (rc)
2553		goto bad;
2554
2555	if (p->policyvers >= POLICYDB_VERSION_BOOL) {
2556		rc = cond_read_list(p, fp);
2557		if (rc)
2558			goto bad;
2559	}
2560
2561	rc = next_entry(buf, fp, sizeof(u32));
2562	if (rc)
2563		goto bad;
2564	nel = le32_to_cpu(buf[0]);
2565
2566	rc = hashtab_init(&p->role_tr, nel);
2567	if (rc)
2568		goto bad;
2569	for (i = 0; i < nel; i++) {
2570		rc = -ENOMEM;
2571		rtk = kmalloc(sizeof(*rtk), GFP_KERNEL);
2572		if (!rtk)
2573			goto bad;
2574
2575		rc = -ENOMEM;
2576		rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
2577		if (!rtd)
2578			goto bad;
2579
2580		rc = next_entry(buf, fp, sizeof(u32)*3);
2581		if (rc)
2582			goto bad;
2583
2584		rtk->role = le32_to_cpu(buf[0]);
2585		rtk->type = le32_to_cpu(buf[1]);
2586		rtd->new_role = le32_to_cpu(buf[2]);
 
2587		if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) {
2588			rc = next_entry(buf, fp, sizeof(u32));
2589			if (rc)
2590				goto bad;
2591			rtk->tclass = le32_to_cpu(buf[0]);
2592		} else
2593			rtk->tclass = p->process_class;
2594
2595		rc = -EINVAL;
2596		if (!policydb_role_isvalid(p, rtk->role) ||
2597		    !policydb_type_isvalid(p, rtk->type) ||
2598		    !policydb_class_isvalid(p, rtk->tclass) ||
2599		    !policydb_role_isvalid(p, rtd->new_role))
2600			goto bad;
2601
2602		rc = hashtab_insert(&p->role_tr, rtk, rtd, roletr_key_params);
2603		if (rc)
 
 
2604			goto bad;
2605
2606		rtk = NULL;
2607		rtd = NULL;
2608	}
2609
2610	rc = next_entry(buf, fp, sizeof(u32));
2611	if (rc)
2612		goto bad;
2613	nel = le32_to_cpu(buf[0]);
2614	lra = NULL;
2615	for (i = 0; i < nel; i++) {
2616		rc = -ENOMEM;
2617		ra = kzalloc(sizeof(*ra), GFP_KERNEL);
2618		if (!ra)
2619			goto bad;
2620		if (lra)
2621			lra->next = ra;
2622		else
2623			p->role_allow = ra;
2624		rc = next_entry(buf, fp, sizeof(u32)*2);
2625		if (rc)
2626			goto bad;
2627
2628		rc = -EINVAL;
2629		ra->role = le32_to_cpu(buf[0]);
2630		ra->new_role = le32_to_cpu(buf[1]);
2631		if (!policydb_role_isvalid(p, ra->role) ||
2632		    !policydb_role_isvalid(p, ra->new_role))
2633			goto bad;
2634		lra = ra;
2635	}
2636
2637	rc = filename_trans_read(p, fp);
2638	if (rc)
2639		goto bad;
2640
2641	rc = policydb_index(p);
2642	if (rc)
2643		goto bad;
2644
2645	rc = -EINVAL;
2646	perm = string_to_av_perm(p, p->process_class, "transition");
2647	if (!perm) {
2648		pr_err("SELinux: process transition permission is required, not defined in policy\n");
2649		goto bad;
2650	}
2651	p->process_trans_perms = perm;
2652	perm = string_to_av_perm(p, p->process_class, "dyntransition");
2653	if (!perm) {
2654		pr_err("SELinux: process dyntransition permission is required, not defined in policy\n");
2655		goto bad;
2656	}
2657	p->process_trans_perms |= perm;
2658
2659	rc = ocontext_read(p, info, fp);
2660	if (rc)
2661		goto bad;
2662
2663	rc = genfs_read(p, fp);
2664	if (rc)
2665		goto bad;
2666
2667	rc = range_read(p, fp);
2668	if (rc)
2669		goto bad;
2670
2671	rc = -ENOMEM;
2672	p->type_attr_map_array = kvcalloc(p->p_types.nprim,
2673					  sizeof(*p->type_attr_map_array),
2674					  GFP_KERNEL);
2675	if (!p->type_attr_map_array)
2676		goto bad;
2677
2678	/* just in case ebitmap_init() becomes more than just a memset(0): */
2679	for (i = 0; i < p->p_types.nprim; i++)
2680		ebitmap_init(&p->type_attr_map_array[i]);
 
 
2681
2682	for (i = 0; i < p->p_types.nprim; i++) {
2683		struct ebitmap *e = &p->type_attr_map_array[i];
2684
 
 
2685		if (p->policyvers >= POLICYDB_VERSION_AVTAB) {
2686			rc = ebitmap_read(e, fp);
2687			if (rc)
2688				goto bad;
2689		}
2690		/* add the type itself as the degenerate case */
2691		rc = ebitmap_set_bit(e, i, 1);
2692		if (rc)
2693			goto bad;
2694	}
2695
2696	rc = policydb_bounds_sanity_check(p);
2697	if (rc)
2698		goto bad;
2699
2700	rc = 0;
2701out:
2702	return rc;
2703bad:
2704	kfree(rtk);
2705	kfree(rtd);
2706	policydb_destroy(p);
2707	goto out;
2708}
2709
2710/*
2711 * Write a MLS level structure to a policydb binary
2712 * representation file.
2713 */
2714static int mls_write_level(struct mls_level *l, void *fp)
2715{
2716	__le32 buf[1];
2717	int rc;
2718
2719	buf[0] = cpu_to_le32(l->sens);
2720	rc = put_entry(buf, sizeof(u32), 1, fp);
2721	if (rc)
2722		return rc;
2723
2724	rc = ebitmap_write(&l->cat, fp);
2725	if (rc)
2726		return rc;
2727
2728	return 0;
2729}
2730
2731/*
2732 * Write a MLS range structure to a policydb binary
2733 * representation file.
2734 */
2735static int mls_write_range_helper(struct mls_range *r, void *fp)
2736{
2737	__le32 buf[3];
2738	size_t items;
2739	int rc, eq;
2740
2741	eq = mls_level_eq(&r->level[1], &r->level[0]);
2742
2743	if (eq)
2744		items = 2;
2745	else
2746		items = 3;
2747	buf[0] = cpu_to_le32(items-1);
2748	buf[1] = cpu_to_le32(r->level[0].sens);
2749	if (!eq)
2750		buf[2] = cpu_to_le32(r->level[1].sens);
2751
2752	BUG_ON(items > ARRAY_SIZE(buf));
2753
2754	rc = put_entry(buf, sizeof(u32), items, fp);
2755	if (rc)
2756		return rc;
2757
2758	rc = ebitmap_write(&r->level[0].cat, fp);
2759	if (rc)
2760		return rc;
2761	if (!eq) {
2762		rc = ebitmap_write(&r->level[1].cat, fp);
2763		if (rc)
2764			return rc;
2765	}
2766
2767	return 0;
2768}
2769
2770static int sens_write(void *vkey, void *datum, void *ptr)
2771{
2772	char *key = vkey;
2773	struct level_datum *levdatum = datum;
2774	struct policy_data *pd = ptr;
2775	void *fp = pd->fp;
2776	__le32 buf[2];
2777	size_t len;
2778	int rc;
2779
2780	len = strlen(key);
2781	buf[0] = cpu_to_le32(len);
2782	buf[1] = cpu_to_le32(levdatum->isalias);
2783	rc = put_entry(buf, sizeof(u32), 2, fp);
2784	if (rc)
2785		return rc;
2786
2787	rc = put_entry(key, 1, len, fp);
2788	if (rc)
2789		return rc;
2790
2791	rc = mls_write_level(levdatum->level, fp);
2792	if (rc)
2793		return rc;
2794
2795	return 0;
2796}
2797
2798static int cat_write(void *vkey, void *datum, void *ptr)
2799{
2800	char *key = vkey;
2801	struct cat_datum *catdatum = datum;
2802	struct policy_data *pd = ptr;
2803	void *fp = pd->fp;
2804	__le32 buf[3];
2805	size_t len;
2806	int rc;
2807
2808	len = strlen(key);
2809	buf[0] = cpu_to_le32(len);
2810	buf[1] = cpu_to_le32(catdatum->value);
2811	buf[2] = cpu_to_le32(catdatum->isalias);
2812	rc = put_entry(buf, sizeof(u32), 3, fp);
2813	if (rc)
2814		return rc;
2815
2816	rc = put_entry(key, 1, len, fp);
2817	if (rc)
2818		return rc;
2819
2820	return 0;
2821}
2822
2823static int role_trans_write_one(void *key, void *datum, void *ptr)
2824{
2825	struct role_trans_key *rtk = key;
2826	struct role_trans_datum *rtd = datum;
2827	struct policy_data *pd = ptr;
2828	void *fp = pd->fp;
2829	struct policydb *p = pd->p;
2830	__le32 buf[3];
2831	int rc;
2832
2833	buf[0] = cpu_to_le32(rtk->role);
2834	buf[1] = cpu_to_le32(rtk->type);
2835	buf[2] = cpu_to_le32(rtd->new_role);
2836	rc = put_entry(buf, sizeof(u32), 3, fp);
 
2837	if (rc)
2838		return rc;
2839	if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) {
2840		buf[0] = cpu_to_le32(rtk->tclass);
2841		rc = put_entry(buf, sizeof(u32), 1, fp);
 
 
2842		if (rc)
2843			return rc;
 
 
 
 
 
 
2844	}
2845	return 0;
2846}
2847
2848static int role_trans_write(struct policydb *p, void *fp)
2849{
2850	struct policy_data pd = { .p = p, .fp = fp };
2851	__le32 buf[1];
2852	int rc;
2853
2854	buf[0] = cpu_to_le32(p->role_tr.nel);
2855	rc = put_entry(buf, sizeof(u32), 1, fp);
2856	if (rc)
2857		return rc;
2858
2859	return hashtab_map(&p->role_tr, role_trans_write_one, &pd);
2860}
2861
2862static int role_allow_write(struct role_allow *r, void *fp)
2863{
2864	struct role_allow *ra;
2865	__le32 buf[2];
2866	size_t nel;
2867	int rc;
2868
2869	nel = 0;
2870	for (ra = r; ra; ra = ra->next)
2871		nel++;
2872	buf[0] = cpu_to_le32(nel);
2873	rc = put_entry(buf, sizeof(u32), 1, fp);
2874	if (rc)
2875		return rc;
2876	for (ra = r; ra; ra = ra->next) {
2877		buf[0] = cpu_to_le32(ra->role);
2878		buf[1] = cpu_to_le32(ra->new_role);
2879		rc = put_entry(buf, sizeof(u32), 2, fp);
2880		if (rc)
2881			return rc;
2882	}
2883	return 0;
2884}
2885
2886/*
2887 * Write a security context structure
2888 * to a policydb binary representation file.
2889 */
2890static int context_write(struct policydb *p, struct context *c,
2891			 void *fp)
2892{
2893	int rc;
2894	__le32 buf[3];
2895
2896	buf[0] = cpu_to_le32(c->user);
2897	buf[1] = cpu_to_le32(c->role);
2898	buf[2] = cpu_to_le32(c->type);
2899
2900	rc = put_entry(buf, sizeof(u32), 3, fp);
2901	if (rc)
2902		return rc;
2903
2904	rc = mls_write_range_helper(&c->range, fp);
2905	if (rc)
2906		return rc;
2907
2908	return 0;
2909}
2910
2911/*
2912 * The following *_write functions are used to
2913 * write the symbol data to a policy database
2914 * binary representation file.
2915 */
2916
2917static int perm_write(void *vkey, void *datum, void *fp)
2918{
2919	char *key = vkey;
2920	struct perm_datum *perdatum = datum;
2921	__le32 buf[2];
2922	size_t len;
2923	int rc;
2924
2925	len = strlen(key);
2926	buf[0] = cpu_to_le32(len);
2927	buf[1] = cpu_to_le32(perdatum->value);
2928	rc = put_entry(buf, sizeof(u32), 2, fp);
2929	if (rc)
2930		return rc;
2931
2932	rc = put_entry(key, 1, len, fp);
2933	if (rc)
2934		return rc;
2935
2936	return 0;
2937}
2938
2939static int common_write(void *vkey, void *datum, void *ptr)
2940{
2941	char *key = vkey;
2942	struct common_datum *comdatum = datum;
2943	struct policy_data *pd = ptr;
2944	void *fp = pd->fp;
2945	__le32 buf[4];
2946	size_t len;
2947	int rc;
2948
2949	len = strlen(key);
2950	buf[0] = cpu_to_le32(len);
2951	buf[1] = cpu_to_le32(comdatum->value);
2952	buf[2] = cpu_to_le32(comdatum->permissions.nprim);
2953	buf[3] = cpu_to_le32(comdatum->permissions.table.nel);
2954	rc = put_entry(buf, sizeof(u32), 4, fp);
2955	if (rc)
2956		return rc;
2957
2958	rc = put_entry(key, 1, len, fp);
2959	if (rc)
2960		return rc;
2961
2962	rc = hashtab_map(&comdatum->permissions.table, perm_write, fp);
2963	if (rc)
2964		return rc;
2965
2966	return 0;
2967}
2968
2969static int type_set_write(struct type_set *t, void *fp)
2970{
2971	int rc;
2972	__le32 buf[1];
2973
2974	if (ebitmap_write(&t->types, fp))
2975		return -EINVAL;
2976	if (ebitmap_write(&t->negset, fp))
2977		return -EINVAL;
2978
2979	buf[0] = cpu_to_le32(t->flags);
2980	rc = put_entry(buf, sizeof(u32), 1, fp);
2981	if (rc)
2982		return -EINVAL;
2983
2984	return 0;
2985}
2986
2987static int write_cons_helper(struct policydb *p, struct constraint_node *node,
2988			     void *fp)
2989{
2990	struct constraint_node *c;
2991	struct constraint_expr *e;
2992	__le32 buf[3];
2993	u32 nel;
2994	int rc;
2995
2996	for (c = node; c; c = c->next) {
2997		nel = 0;
2998		for (e = c->expr; e; e = e->next)
2999			nel++;
3000		buf[0] = cpu_to_le32(c->permissions);
3001		buf[1] = cpu_to_le32(nel);
3002		rc = put_entry(buf, sizeof(u32), 2, fp);
3003		if (rc)
3004			return rc;
3005		for (e = c->expr; e; e = e->next) {
3006			buf[0] = cpu_to_le32(e->expr_type);
3007			buf[1] = cpu_to_le32(e->attr);
3008			buf[2] = cpu_to_le32(e->op);
3009			rc = put_entry(buf, sizeof(u32), 3, fp);
3010			if (rc)
3011				return rc;
3012
3013			switch (e->expr_type) {
3014			case CEXPR_NAMES:
3015				rc = ebitmap_write(&e->names, fp);
3016				if (rc)
3017					return rc;
3018				if (p->policyvers >=
3019					POLICYDB_VERSION_CONSTRAINT_NAMES) {
3020					rc = type_set_write(e->type_names, fp);
3021					if (rc)
3022						return rc;
3023				}
3024				break;
3025			default:
3026				break;
3027			}
3028		}
3029	}
3030
3031	return 0;
3032}
3033
3034static int class_write(void *vkey, void *datum, void *ptr)
3035{
3036	char *key = vkey;
3037	struct class_datum *cladatum = datum;
3038	struct policy_data *pd = ptr;
3039	void *fp = pd->fp;
3040	struct policydb *p = pd->p;
3041	struct constraint_node *c;
3042	__le32 buf[6];
3043	u32 ncons;
3044	size_t len, len2;
3045	int rc;
3046
3047	len = strlen(key);
3048	if (cladatum->comkey)
3049		len2 = strlen(cladatum->comkey);
3050	else
3051		len2 = 0;
3052
3053	ncons = 0;
3054	for (c = cladatum->constraints; c; c = c->next)
3055		ncons++;
3056
3057	buf[0] = cpu_to_le32(len);
3058	buf[1] = cpu_to_le32(len2);
3059	buf[2] = cpu_to_le32(cladatum->value);
3060	buf[3] = cpu_to_le32(cladatum->permissions.nprim);
3061	buf[4] = cpu_to_le32(cladatum->permissions.table.nel);
 
 
 
3062	buf[5] = cpu_to_le32(ncons);
3063	rc = put_entry(buf, sizeof(u32), 6, fp);
3064	if (rc)
3065		return rc;
3066
3067	rc = put_entry(key, 1, len, fp);
3068	if (rc)
3069		return rc;
3070
3071	if (cladatum->comkey) {
3072		rc = put_entry(cladatum->comkey, 1, len2, fp);
3073		if (rc)
3074			return rc;
3075	}
3076
3077	rc = hashtab_map(&cladatum->permissions.table, perm_write, fp);
3078	if (rc)
3079		return rc;
3080
3081	rc = write_cons_helper(p, cladatum->constraints, fp);
3082	if (rc)
3083		return rc;
3084
3085	/* write out the validatetrans rule */
3086	ncons = 0;
3087	for (c = cladatum->validatetrans; c; c = c->next)
3088		ncons++;
3089
3090	buf[0] = cpu_to_le32(ncons);
3091	rc = put_entry(buf, sizeof(u32), 1, fp);
3092	if (rc)
3093		return rc;
3094
3095	rc = write_cons_helper(p, cladatum->validatetrans, fp);
3096	if (rc)
3097		return rc;
3098
3099	if (p->policyvers >= POLICYDB_VERSION_NEW_OBJECT_DEFAULTS) {
3100		buf[0] = cpu_to_le32(cladatum->default_user);
3101		buf[1] = cpu_to_le32(cladatum->default_role);
3102		buf[2] = cpu_to_le32(cladatum->default_range);
3103
3104		rc = put_entry(buf, sizeof(uint32_t), 3, fp);
3105		if (rc)
3106			return rc;
3107	}
3108
3109	if (p->policyvers >= POLICYDB_VERSION_DEFAULT_TYPE) {
3110		buf[0] = cpu_to_le32(cladatum->default_type);
3111		rc = put_entry(buf, sizeof(uint32_t), 1, fp);
3112		if (rc)
3113			return rc;
3114	}
3115
3116	return 0;
3117}
3118
3119static int role_write(void *vkey, void *datum, void *ptr)
3120{
3121	char *key = vkey;
3122	struct role_datum *role = datum;
3123	struct policy_data *pd = ptr;
3124	void *fp = pd->fp;
3125	struct policydb *p = pd->p;
3126	__le32 buf[3];
3127	size_t items, len;
3128	int rc;
3129
3130	len = strlen(key);
3131	items = 0;
3132	buf[items++] = cpu_to_le32(len);
3133	buf[items++] = cpu_to_le32(role->value);
3134	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
3135		buf[items++] = cpu_to_le32(role->bounds);
3136
3137	BUG_ON(items > ARRAY_SIZE(buf));
3138
3139	rc = put_entry(buf, sizeof(u32), items, fp);
3140	if (rc)
3141		return rc;
3142
3143	rc = put_entry(key, 1, len, fp);
3144	if (rc)
3145		return rc;
3146
3147	rc = ebitmap_write(&role->dominates, fp);
3148	if (rc)
3149		return rc;
3150
3151	rc = ebitmap_write(&role->types, fp);
3152	if (rc)
3153		return rc;
3154
3155	return 0;
3156}
3157
3158static int type_write(void *vkey, void *datum, void *ptr)
3159{
3160	char *key = vkey;
3161	struct type_datum *typdatum = datum;
3162	struct policy_data *pd = ptr;
3163	struct policydb *p = pd->p;
3164	void *fp = pd->fp;
3165	__le32 buf[4];
3166	int rc;
3167	size_t items, len;
3168
3169	len = strlen(key);
3170	items = 0;
3171	buf[items++] = cpu_to_le32(len);
3172	buf[items++] = cpu_to_le32(typdatum->value);
3173	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) {
3174		u32 properties = 0;
3175
3176		if (typdatum->primary)
3177			properties |= TYPEDATUM_PROPERTY_PRIMARY;
3178
3179		if (typdatum->attribute)
3180			properties |= TYPEDATUM_PROPERTY_ATTRIBUTE;
3181
3182		buf[items++] = cpu_to_le32(properties);
3183		buf[items++] = cpu_to_le32(typdatum->bounds);
3184	} else {
3185		buf[items++] = cpu_to_le32(typdatum->primary);
3186	}
3187	BUG_ON(items > ARRAY_SIZE(buf));
3188	rc = put_entry(buf, sizeof(u32), items, fp);
3189	if (rc)
3190		return rc;
3191
3192	rc = put_entry(key, 1, len, fp);
3193	if (rc)
3194		return rc;
3195
3196	return 0;
3197}
3198
3199static int user_write(void *vkey, void *datum, void *ptr)
3200{
3201	char *key = vkey;
3202	struct user_datum *usrdatum = datum;
3203	struct policy_data *pd = ptr;
3204	struct policydb *p = pd->p;
3205	void *fp = pd->fp;
3206	__le32 buf[3];
3207	size_t items, len;
3208	int rc;
3209
3210	len = strlen(key);
3211	items = 0;
3212	buf[items++] = cpu_to_le32(len);
3213	buf[items++] = cpu_to_le32(usrdatum->value);
3214	if (p->policyvers >= POLICYDB_VERSION_BOUNDARY)
3215		buf[items++] = cpu_to_le32(usrdatum->bounds);
3216	BUG_ON(items > ARRAY_SIZE(buf));
3217	rc = put_entry(buf, sizeof(u32), items, fp);
3218	if (rc)
3219		return rc;
3220
3221	rc = put_entry(key, 1, len, fp);
3222	if (rc)
3223		return rc;
3224
3225	rc = ebitmap_write(&usrdatum->roles, fp);
3226	if (rc)
3227		return rc;
3228
3229	rc = mls_write_range_helper(&usrdatum->range, fp);
3230	if (rc)
3231		return rc;
3232
3233	rc = mls_write_level(&usrdatum->dfltlevel, fp);
3234	if (rc)
3235		return rc;
3236
3237	return 0;
3238}
3239
3240static int (*const write_f[SYM_NUM]) (void *key, void *datum, void *datap) = {
 
 
3241	common_write,
3242	class_write,
3243	role_write,
3244	type_write,
3245	user_write,
3246	cond_write_bool,
3247	sens_write,
3248	cat_write,
3249};
3250
3251static int ocontext_write(struct policydb *p, const struct policydb_compat_info *info,
3252			  void *fp)
3253{
3254	unsigned int i, j, rc;
3255	size_t nel, len;
3256	__be64 prefixbuf[1];
3257	__le32 buf[3];
3258	u32 nodebuf[8];
3259	struct ocontext *c;
3260	for (i = 0; i < info->ocon_num; i++) {
3261		nel = 0;
3262		for (c = p->ocontexts[i]; c; c = c->next)
3263			nel++;
3264		buf[0] = cpu_to_le32(nel);
3265		rc = put_entry(buf, sizeof(u32), 1, fp);
3266		if (rc)
3267			return rc;
3268		for (c = p->ocontexts[i]; c; c = c->next) {
3269			switch (i) {
3270			case OCON_ISID:
3271				buf[0] = cpu_to_le32(c->sid[0]);
3272				rc = put_entry(buf, sizeof(u32), 1, fp);
3273				if (rc)
3274					return rc;
3275				rc = context_write(p, &c->context[0], fp);
3276				if (rc)
3277					return rc;
3278				break;
3279			case OCON_FS:
3280			case OCON_NETIF:
3281				len = strlen(c->u.name);
3282				buf[0] = cpu_to_le32(len);
3283				rc = put_entry(buf, sizeof(u32), 1, fp);
3284				if (rc)
3285					return rc;
3286				rc = put_entry(c->u.name, 1, len, fp);
3287				if (rc)
3288					return rc;
3289				rc = context_write(p, &c->context[0], fp);
3290				if (rc)
3291					return rc;
3292				rc = context_write(p, &c->context[1], fp);
3293				if (rc)
3294					return rc;
3295				break;
3296			case OCON_PORT:
3297				buf[0] = cpu_to_le32(c->u.port.protocol);
3298				buf[1] = cpu_to_le32(c->u.port.low_port);
3299				buf[2] = cpu_to_le32(c->u.port.high_port);
3300				rc = put_entry(buf, sizeof(u32), 3, fp);
3301				if (rc)
3302					return rc;
3303				rc = context_write(p, &c->context[0], fp);
3304				if (rc)
3305					return rc;
3306				break;
3307			case OCON_NODE:
3308				nodebuf[0] = c->u.node.addr; /* network order */
3309				nodebuf[1] = c->u.node.mask; /* network order */
3310				rc = put_entry(nodebuf, sizeof(u32), 2, fp);
3311				if (rc)
3312					return rc;
3313				rc = context_write(p, &c->context[0], fp);
3314				if (rc)
3315					return rc;
3316				break;
3317			case OCON_FSUSE:
3318				buf[0] = cpu_to_le32(c->v.behavior);
3319				len = strlen(c->u.name);
3320				buf[1] = cpu_to_le32(len);
3321				rc = put_entry(buf, sizeof(u32), 2, fp);
3322				if (rc)
3323					return rc;
3324				rc = put_entry(c->u.name, 1, len, fp);
3325				if (rc)
3326					return rc;
3327				rc = context_write(p, &c->context[0], fp);
3328				if (rc)
3329					return rc;
3330				break;
3331			case OCON_NODE6:
3332				for (j = 0; j < 4; j++)
3333					nodebuf[j] = c->u.node6.addr[j]; /* network order */
3334				for (j = 0; j < 4; j++)
3335					nodebuf[j + 4] = c->u.node6.mask[j]; /* network order */
3336				rc = put_entry(nodebuf, sizeof(u32), 8, fp);
3337				if (rc)
3338					return rc;
3339				rc = context_write(p, &c->context[0], fp);
3340				if (rc)
3341					return rc;
3342				break;
3343			case OCON_IBPKEY:
3344				/* subnet_prefix is in CPU order */
3345				prefixbuf[0] = cpu_to_be64(c->u.ibpkey.subnet_prefix);
3346
3347				rc = put_entry(prefixbuf, sizeof(u64), 1, fp);
3348				if (rc)
3349					return rc;
3350
3351				buf[0] = cpu_to_le32(c->u.ibpkey.low_pkey);
3352				buf[1] = cpu_to_le32(c->u.ibpkey.high_pkey);
3353
3354				rc = put_entry(buf, sizeof(u32), 2, fp);
3355				if (rc)
3356					return rc;
3357				rc = context_write(p, &c->context[0], fp);
3358				if (rc)
3359					return rc;
3360				break;
3361			case OCON_IBENDPORT:
3362				len = strlen(c->u.ibendport.dev_name);
3363				buf[0] = cpu_to_le32(len);
3364				buf[1] = cpu_to_le32(c->u.ibendport.port);
3365				rc = put_entry(buf, sizeof(u32), 2, fp);
3366				if (rc)
3367					return rc;
3368				rc = put_entry(c->u.ibendport.dev_name, 1, len, fp);
3369				if (rc)
3370					return rc;
3371				rc = context_write(p, &c->context[0], fp);
3372				if (rc)
3373					return rc;
3374				break;
3375			}
3376		}
3377	}
3378	return 0;
3379}
3380
3381static int genfs_write(struct policydb *p, void *fp)
3382{
3383	struct genfs *genfs;
3384	struct ocontext *c;
3385	size_t len;
3386	__le32 buf[1];
3387	int rc;
3388
3389	len = 0;
3390	for (genfs = p->genfs; genfs; genfs = genfs->next)
3391		len++;
3392	buf[0] = cpu_to_le32(len);
3393	rc = put_entry(buf, sizeof(u32), 1, fp);
3394	if (rc)
3395		return rc;
3396	for (genfs = p->genfs; genfs; genfs = genfs->next) {
3397		len = strlen(genfs->fstype);
3398		buf[0] = cpu_to_le32(len);
3399		rc = put_entry(buf, sizeof(u32), 1, fp);
3400		if (rc)
3401			return rc;
3402		rc = put_entry(genfs->fstype, 1, len, fp);
3403		if (rc)
3404			return rc;
3405		len = 0;
3406		for (c = genfs->head; c; c = c->next)
3407			len++;
3408		buf[0] = cpu_to_le32(len);
3409		rc = put_entry(buf, sizeof(u32), 1, fp);
3410		if (rc)
3411			return rc;
3412		for (c = genfs->head; c; c = c->next) {
3413			len = strlen(c->u.name);
3414			buf[0] = cpu_to_le32(len);
3415			rc = put_entry(buf, sizeof(u32), 1, fp);
3416			if (rc)
3417				return rc;
3418			rc = put_entry(c->u.name, 1, len, fp);
3419			if (rc)
3420				return rc;
3421			buf[0] = cpu_to_le32(c->v.sclass);
3422			rc = put_entry(buf, sizeof(u32), 1, fp);
3423			if (rc)
3424				return rc;
3425			rc = context_write(p, &c->context[0], fp);
3426			if (rc)
3427				return rc;
3428		}
3429	}
3430	return 0;
3431}
3432
 
 
 
 
 
 
 
 
3433static int range_write_helper(void *key, void *data, void *ptr)
3434{
3435	__le32 buf[2];
3436	struct range_trans *rt = key;
3437	struct mls_range *r = data;
3438	struct policy_data *pd = ptr;
3439	void *fp = pd->fp;
3440	struct policydb *p = pd->p;
3441	int rc;
3442
3443	buf[0] = cpu_to_le32(rt->source_type);
3444	buf[1] = cpu_to_le32(rt->target_type);
3445	rc = put_entry(buf, sizeof(u32), 2, fp);
3446	if (rc)
3447		return rc;
3448	if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) {
3449		buf[0] = cpu_to_le32(rt->target_class);
3450		rc = put_entry(buf, sizeof(u32), 1, fp);
3451		if (rc)
3452			return rc;
3453	}
3454	rc = mls_write_range_helper(r, fp);
3455	if (rc)
3456		return rc;
3457
3458	return 0;
3459}
3460
3461static int range_write(struct policydb *p, void *fp)
3462{
3463	__le32 buf[1];
3464	int rc;
3465	struct policy_data pd;
3466
3467	pd.p = p;
3468	pd.fp = fp;
3469
3470	buf[0] = cpu_to_le32(p->range_tr.nel);
 
 
 
 
 
 
3471	rc = put_entry(buf, sizeof(u32), 1, fp);
3472	if (rc)
3473		return rc;
3474
3475	/* actually write all of the entries */
3476	rc = hashtab_map(&p->range_tr, range_write_helper, &pd);
3477	if (rc)
3478		return rc;
3479
3480	return 0;
3481}
3482
3483static int filename_write_helper_compat(void *key, void *data, void *ptr)
3484{
3485	struct filename_trans_key *ft = key;
3486	struct filename_trans_datum *datum = data;
3487	struct ebitmap_node *node;
3488	void *fp = ptr;
3489	__le32 buf[4];
3490	int rc;
3491	u32 bit, len = strlen(ft->name);
3492
3493	do {
3494		ebitmap_for_each_positive_bit(&datum->stypes, node, bit) {
3495			buf[0] = cpu_to_le32(len);
3496			rc = put_entry(buf, sizeof(u32), 1, fp);
3497			if (rc)
3498				return rc;
3499
3500			rc = put_entry(ft->name, sizeof(char), len, fp);
3501			if (rc)
3502				return rc;
3503
3504			buf[0] = cpu_to_le32(bit + 1);
3505			buf[1] = cpu_to_le32(ft->ttype);
3506			buf[2] = cpu_to_le32(ft->tclass);
3507			buf[3] = cpu_to_le32(datum->otype);
3508
3509			rc = put_entry(buf, sizeof(u32), 4, fp);
3510			if (rc)
3511				return rc;
3512		}
3513
3514		datum = datum->next;
3515	} while (unlikely(datum));
3516
3517	return 0;
3518}
3519
3520static int filename_write_helper(void *key, void *data, void *ptr)
3521{
3522	struct filename_trans_key *ft = key;
3523	struct filename_trans_datum *datum;
 
3524	void *fp = ptr;
3525	__le32 buf[3];
3526	int rc;
3527	u32 ndatum, len = strlen(ft->name);
3528
 
3529	buf[0] = cpu_to_le32(len);
3530	rc = put_entry(buf, sizeof(u32), 1, fp);
3531	if (rc)
3532		return rc;
3533
3534	rc = put_entry(ft->name, sizeof(char), len, fp);
3535	if (rc)
3536		return rc;
3537
3538	ndatum = 0;
3539	datum = data;
3540	do {
3541		ndatum++;
3542		datum = datum->next;
3543	} while (unlikely(datum));
3544
3545	buf[0] = cpu_to_le32(ft->ttype);
3546	buf[1] = cpu_to_le32(ft->tclass);
3547	buf[2] = cpu_to_le32(ndatum);
3548	rc = put_entry(buf, sizeof(u32), 3, fp);
3549	if (rc)
3550		return rc;
3551
3552	datum = data;
3553	do {
3554		rc = ebitmap_write(&datum->stypes, fp);
3555		if (rc)
3556			return rc;
3557
3558		buf[0] = cpu_to_le32(datum->otype);
3559		rc = put_entry(buf, sizeof(u32), 1, fp);
3560		if (rc)
3561			return rc;
3562
3563		datum = datum->next;
3564	} while (unlikely(datum));
3565
3566	return 0;
3567}
3568
3569static int filename_trans_write(struct policydb *p, void *fp)
3570{
 
3571	__le32 buf[1];
3572	int rc;
3573
3574	if (p->policyvers < POLICYDB_VERSION_FILENAME_TRANS)
3575		return 0;
3576
3577	if (p->policyvers < POLICYDB_VERSION_COMP_FTRANS) {
3578		buf[0] = cpu_to_le32(p->compat_filename_trans_count);
3579		rc = put_entry(buf, sizeof(u32), 1, fp);
3580		if (rc)
3581			return rc;
3582
3583		rc = hashtab_map(&p->filename_trans,
3584				 filename_write_helper_compat, fp);
3585	} else {
3586		buf[0] = cpu_to_le32(p->filename_trans.nel);
3587		rc = put_entry(buf, sizeof(u32), 1, fp);
3588		if (rc)
3589			return rc;
3590
3591		rc = hashtab_map(&p->filename_trans, filename_write_helper, fp);
3592	}
3593	return rc;
 
 
3594}
3595
3596/*
3597 * Write the configuration data in a policy database
3598 * structure to a policy database binary representation
3599 * file.
3600 */
3601int policydb_write(struct policydb *p, void *fp)
3602{
3603	unsigned int i, num_syms;
3604	int rc;
3605	__le32 buf[4];
3606	u32 config;
3607	size_t len;
3608	const struct policydb_compat_info *info;
3609
3610	/*
3611	 * refuse to write policy older than compressed avtab
3612	 * to simplify the writer.  There are other tests dropped
3613	 * since we assume this throughout the writer code.  Be
3614	 * careful if you ever try to remove this restriction
3615	 */
3616	if (p->policyvers < POLICYDB_VERSION_AVTAB) {
3617		pr_err("SELinux: refusing to write policy version %d."
3618		       "  Because it is less than version %d\n", p->policyvers,
3619		       POLICYDB_VERSION_AVTAB);
3620		return -EINVAL;
3621	}
3622
3623	config = 0;
3624	if (p->mls_enabled)
3625		config |= POLICYDB_CONFIG_MLS;
3626
3627	if (p->reject_unknown)
3628		config |= REJECT_UNKNOWN;
3629	if (p->allow_unknown)
3630		config |= ALLOW_UNKNOWN;
3631
3632	/* Write the magic number and string identifiers. */
3633	buf[0] = cpu_to_le32(POLICYDB_MAGIC);
3634	len = strlen(POLICYDB_STRING);
3635	buf[1] = cpu_to_le32(len);
3636	rc = put_entry(buf, sizeof(u32), 2, fp);
3637	if (rc)
3638		return rc;
3639	rc = put_entry(POLICYDB_STRING, 1, len, fp);
3640	if (rc)
3641		return rc;
3642
3643	/* Write the version, config, and table sizes. */
3644	info = policydb_lookup_compat(p->policyvers);
3645	if (!info) {
3646		pr_err("SELinux: compatibility lookup failed for policy "
3647		    "version %d", p->policyvers);
3648		return -EINVAL;
3649	}
3650
3651	buf[0] = cpu_to_le32(p->policyvers);
3652	buf[1] = cpu_to_le32(config);
3653	buf[2] = cpu_to_le32(info->sym_num);
3654	buf[3] = cpu_to_le32(info->ocon_num);
3655
3656	rc = put_entry(buf, sizeof(u32), 4, fp);
3657	if (rc)
3658		return rc;
3659
3660	if (p->policyvers >= POLICYDB_VERSION_POLCAP) {
3661		rc = ebitmap_write(&p->policycaps, fp);
3662		if (rc)
3663			return rc;
3664	}
3665
3666	if (p->policyvers >= POLICYDB_VERSION_PERMISSIVE) {
3667		rc = ebitmap_write(&p->permissive_map, fp);
3668		if (rc)
3669			return rc;
3670	}
3671
3672	num_syms = info->sym_num;
3673	for (i = 0; i < num_syms; i++) {
3674		struct policy_data pd;
3675
3676		pd.fp = fp;
3677		pd.p = p;
3678
3679		buf[0] = cpu_to_le32(p->symtab[i].nprim);
3680		buf[1] = cpu_to_le32(p->symtab[i].table.nel);
3681
3682		rc = put_entry(buf, sizeof(u32), 2, fp);
3683		if (rc)
3684			return rc;
3685		rc = hashtab_map(&p->symtab[i].table, write_f[i], &pd);
3686		if (rc)
3687			return rc;
3688	}
3689
3690	rc = avtab_write(p, &p->te_avtab, fp);
3691	if (rc)
3692		return rc;
3693
3694	rc = cond_write_list(p, fp);
3695	if (rc)
3696		return rc;
3697
3698	rc = role_trans_write(p, fp);
3699	if (rc)
3700		return rc;
3701
3702	rc = role_allow_write(p->role_allow, fp);
3703	if (rc)
3704		return rc;
3705
3706	rc = filename_trans_write(p, fp);
3707	if (rc)
3708		return rc;
3709
3710	rc = ocontext_write(p, info, fp);
3711	if (rc)
3712		return rc;
3713
3714	rc = genfs_write(p, fp);
3715	if (rc)
3716		return rc;
3717
3718	rc = range_write(p, fp);
3719	if (rc)
3720		return rc;
3721
3722	for (i = 0; i < p->p_types.nprim; i++) {
3723		struct ebitmap *e = &p->type_attr_map_array[i];
3724
 
3725		rc = ebitmap_write(e, fp);
3726		if (rc)
3727			return rc;
3728	}
3729
3730	return 0;
3731}