[mirror_ubuntu-zesty-kernel.git] / security / selinux / ss / mls.c

/*
 * Implementation of the multi-level security (MLS) policy.
 *
 * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
 */
/*
 * Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
 *
 *	Support for enhanced MLS infrastructure.
 *
 * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
 */
/*
 * Updated: Hewlett-Packard <paul@paul-moore.com>
 *
 *      Added support to import/export the MLS label from NetLabel
 *
 * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <net/netlabel.h>
#include "sidtab.h"
#include "mls.h"
#include "policydb.h"
#include "services.h"

/*
 * Return the length in bytes for the MLS fields of the
 * security context string representation of `context'.
 */
int mls_compute_context_len(struct context *context)
{
	int i, l, len, head, prev;
	char *nm;
	struct ebitmap *e;
	struct ebitmap_node *node;

	if (!policydb.mls_enabled)
		return 0;

	len = 1; /* for the beginning ":" */
	for (l = 0; l < 2; l++) {
		int index_sens = context->range.level[l].sens;
		len += strlen(sym_name(&policydb, SYM_LEVELS, index_sens - 1));

		/* categories */
		head = -2;
		prev = -2;
		e = &context->range.level[l].cat;
		ebitmap_for_each_positive_bit(e, node, i) {
			if (i - prev > 1) {
				/* one or more negative bits are skipped */
				if (head != prev) {
					nm = sym_name(&policydb, SYM_CATS, prev);
					len += strlen(nm) + 1;
				}
				nm = sym_name(&policydb, SYM_CATS, i);
				len += strlen(nm) + 1;
				head = i;
			}
			prev = i;
		}
		if (prev != head) {
			nm = sym_name(&policydb, SYM_CATS, prev);
			len += strlen(nm) + 1;
		}
		if (l == 0) {
			if (mls_level_eq(&context->range.level[0],
					 &context->range.level[1]))
				break;
			else
				len++;
		}
	}

	return len;
}

/*
 * Write the security context string representation of
 * the MLS fields of `context' into the string `*scontext'.
 * Update `*scontext' to point to the end of the MLS fields.
 */
void mls_sid_to_context(struct context *context,
			char **scontext)
{
	char *scontextp, *nm;
	int i, l, head, prev;
	struct ebitmap *e;
	struct ebitmap_node *node;

	if (!policydb.mls_enabled)
		return;

	scontextp = *scontext;

	*scontextp = ':';
	scontextp++;

	for (l = 0; l < 2; l++) {
		strcpy(scontextp, sym_name(&policydb, SYM_LEVELS,
					   context->range.level[l].sens - 1));
		scontextp += strlen(scontextp);

		/* categories */
		head = -2;
		prev = -2;
		e = &context->range.level[l].cat;
		ebitmap_for_each_positive_bit(e, node, i) {
			if (i - prev > 1) {
				/* one or more negative bits are skipped */
				if (prev != head) {
					if (prev - head > 1)
						*scontextp++ = '.';
					else
						*scontextp++ = ',';
					nm = sym_name(&policydb, SYM_CATS, prev);
					strcpy(scontextp, nm);
					scontextp += strlen(nm);
				}
				if (prev < 0)
					*scontextp++ = ':';
				else
					*scontextp++ = ',';
				nm = sym_name(&policydb, SYM_CATS, i);
				strcpy(scontextp, nm);
				scontextp += strlen(nm);
				head = i;
			}
			prev = i;
		}

		if (prev != head) {
			if (prev - head > 1)
				*scontextp++ = '.';
			else
				*scontextp++ = ',';
			nm = sym_name(&policydb, SYM_CATS, prev);
			strcpy(scontextp, nm);
			scontextp += strlen(nm);
		}

		if (l == 0) {
			if (mls_level_eq(&context->range.level[0],
					 &context->range.level[1]))
				break;
			else
				*scontextp++ = '-';
		}
	}

	*scontext = scontextp;
	return;
}

int mls_level_isvalid(struct policydb *p, struct mls_level *l)
{
	struct level_datum *levdatum;

	if (!l->sens || l->sens > p->p_levels.nprim)
		return 0;
	levdatum = hashtab_search(p->p_levels.table,
				  sym_name(p, SYM_LEVELS, l->sens - 1));
	if (!levdatum)
		return 0;

	/*
	 * Return 1 iff all the bits set in l->cat are also be set in
	 * levdatum->level->cat and no bit in l->cat is larger than
	 * p->p_cats.nprim.
	 */
	return ebitmap_contains(&levdatum->level->cat, &l->cat,
				p->p_cats.nprim);
}

int mls_range_isvalid(struct policydb *p, struct mls_range *r)
{
	return (mls_level_isvalid(p, &r->level[0]) &&
		mls_level_isvalid(p, &r->level[1]) &&
		mls_level_dom(&r->level[1], &r->level[0]));
}

/*
 * Return 1 if the MLS fields in the security context
 * structure `c' are valid.  Return 0 otherwise.
 */
int mls_context_isvalid(struct policydb *p, struct context *c)
{
	struct user_datum *usrdatum;

	if (!p->mls_enabled)
		return 1;

	if (!mls_range_isvalid(p, &c->range))
		return 0;

	if (c->role == OBJECT_R_VAL)
		return 1;

	/*
	 * User must be authorized for the MLS range.
	 */
	if (!c->user || c->user > p->p_users.nprim)
		return 0;
	usrdatum = p->user_val_to_struct[c->user - 1];
	if (!mls_range_contains(usrdatum->range, c->range))
		return 0; /* user may not be associated with range */

	return 1;
}

/*
 * Set the MLS fields in the security context structure
 * `context' based on the string representation in
 * the string `*scontext'.  Update `*scontext' to
 * point to the end of the string representation of
 * the MLS fields.
 *
 * This function modifies the string in place, inserting
 * NULL characters to terminate the MLS fields.
 *
 * If a def_sid is provided and no MLS field is present,
 * copy the MLS field of the associated default context.
 * Used for upgraded to MLS systems where objects may lack
 * MLS fields.
 *
 * Policy read-lock must be held for sidtab lookup.
 *
 */
int mls_context_to_sid(struct policydb *pol,
		       char oldc,
		       char **scontext,
		       struct context *context,
		       struct sidtab *s,
		       u32 def_sid)
{

	char delim;
	char *scontextp, *p, *rngptr;
	struct level_datum *levdatum;
	struct cat_datum *catdatum, *rngdatum;
	int l, rc = -EINVAL;

	if (!pol->mls_enabled) {
		if (def_sid != SECSID_NULL && oldc)
			*scontext += strlen(*scontext) + 1;
		return 0;
	}

	/*
	 * No MLS component to the security context, try and map to
	 * default if provided.
	 */
	if (!oldc) {
		struct context *defcon;

		if (def_sid == SECSID_NULL)
			goto out;

		defcon = sidtab_search(s, def_sid);
		if (!defcon)
			goto out;

		rc = mls_context_cpy(context, defcon);
		goto out;
	}

	/* Extract low sensitivity. */
	scontextp = p = *scontext;
	while (*p && *p != ':' && *p != '-')
		p++;

	delim = *p;
	if (delim != '\0')
		*p++ = '\0';

	for (l = 0; l < 2; l++) {
		levdatum = hashtab_search(pol->p_levels.table, scontextp);
		if (!levdatum) {
			rc = -EINVAL;
			goto out;
		}

		context->range.level[l].sens = levdatum->level->sens;

		if (delim == ':') {
			/* Extract category set. */
			while (1) {
				scontextp = p;
				while (*p && *p != ',' && *p != '-')
					p++;
				delim = *p;
				if (delim != '\0')
					*p++ = '\0';

				/* Separate into range if exists */
				rngptr = strchr(scontextp, '.');
				if (rngptr != NULL) {
					/* Remove '.' */
					*rngptr++ = '\0';
				}

				catdatum = hashtab_search(pol->p_cats.table,
							  scontextp);
				if (!catdatum) {
					rc = -EINVAL;
					goto out;
				}

				rc = ebitmap_set_bit(&context->range.level[l].cat,
						     catdatum->value - 1, 1);
				if (rc)
					goto out;

				/* If range, set all categories in range */
				if (rngptr) {
					int i;

					rngdatum = hashtab_search(pol->p_cats.table, rngptr);
					if (!rngdatum) {
						rc = -EINVAL;
						goto out;
					}

					if (catdatum->value >= rngdatum->value) {
						rc = -EINVAL;
						goto out;
					}

					for (i = catdatum->value; i < rngdatum->value; i++) {
						rc = ebitmap_set_bit(&context->range.level[l].cat, i, 1);
						if (rc)
							goto out;
					}
				}

				if (delim != ',')
					break;
			}
		}
		if (delim == '-') {
			/* Extract high sensitivity. */
			scontextp = p;
			while (*p && *p != ':')
				p++;

			delim = *p;
			if (delim != '\0')
				*p++ = '\0';
		} else
			break;
	}

	if (l == 0) {
		context->range.level[1].sens = context->range.level[0].sens;
		rc = ebitmap_cpy(&context->range.level[1].cat,
				 &context->range.level[0].cat);
		if (rc)
			goto out;
	}
	*scontext = ++p;
	rc = 0;
out:
	return rc;
}

/*
 * Set the MLS fields in the security context structure
 * `context' based on the string representation in
 * the string `str'.  This function will allocate temporary memory with the
 * given constraints of gfp_mask.
 */
int mls_from_string(char *str, struct context *context, gfp_t gfp_mask)
{
	char *tmpstr, *freestr;
	int rc;

	if (!policydb.mls_enabled)
		return -EINVAL;

	/* we need freestr because mls_context_to_sid will change
	   the value of tmpstr */
	tmpstr = freestr = kstrdup(str, gfp_mask);
	if (!tmpstr) {
		rc = -ENOMEM;
	} else {
		rc = mls_context_to_sid(&policydb, ':', &tmpstr, context,
					NULL, SECSID_NULL);
		kfree(freestr);
	}

	return rc;
}

/*
 * Copies the MLS range `range' into `context'.
 */
int mls_range_set(struct context *context,
				struct mls_range *range)
{
	int l, rc = 0;

	/* Copy the MLS range into the  context */
	for (l = 0; l < 2; l++) {
		context->range.level[l].sens = range->level[l].sens;
		rc = ebitmap_cpy(&context->range.level[l].cat,
				 &range->level[l].cat);
		if (rc)
			break;
	}

	return rc;
}

int mls_setup_user_range(struct context *fromcon, struct user_datum *user,
			 struct context *usercon)
{
	if (policydb.mls_enabled) {
		struct mls_level *fromcon_sen = &(fromcon->range.level[0]);
		struct mls_level *fromcon_clr = &(fromcon->range.level[1]);
		struct mls_level *user_low = &(user->range.level[0]);
		struct mls_level *user_clr = &(user->range.level[1]);
		struct mls_level *user_def = &(user->dfltlevel);
		struct mls_level *usercon_sen = &(usercon->range.level[0]);
		struct mls_level *usercon_clr = &(usercon->range.level[1]);

		/* Honor the user's default level if we can */
		if (mls_level_between(user_def, fromcon_sen, fromcon_clr))
			*usercon_sen = *user_def;
		else if (mls_level_between(fromcon_sen, user_def, user_clr))
			*usercon_sen = *fromcon_sen;
		else if (mls_level_between(fromcon_clr, user_low, user_def))
			*usercon_sen = *user_low;
		else
			return -EINVAL;

		/* Lower the clearance of available contexts
		   if the clearance of "fromcon" is lower than
		   that of the user's default clearance (but
		   only if the "fromcon" clearance dominates
		   the user's computed sensitivity level) */
		if (mls_level_dom(user_clr, fromcon_clr))
			*usercon_clr = *fromcon_clr;
		else if (mls_level_dom(fromcon_clr, user_clr))
			*usercon_clr = *user_clr;
		else
			return -EINVAL;
	}

	return 0;
}

/*
 * Convert the MLS fields in the security context
 * structure `c' from the values specified in the
 * policy `oldp' to the values specified in the policy `newp'.
 */
int mls_convert_context(struct policydb *oldp,
			struct policydb *newp,
			struct context *c)
{
	struct level_datum *levdatum;
	struct cat_datum *catdatum;
	struct ebitmap bitmap;
	struct ebitmap_node *node;
	int l, i;

	if (!policydb.mls_enabled)
		return 0;

	for (l = 0; l < 2; l++) {
		levdatum = hashtab_search(newp->p_levels.table,
					  sym_name(oldp, SYM_LEVELS,
						   c->range.level[l].sens - 1));

		if (!levdatum)
			return -EINVAL;
		c->range.level[l].sens = levdatum->level->sens;

		ebitmap_init(&bitmap);
		ebitmap_for_each_positive_bit(&c->range.level[l].cat, node, i) {
			int rc;

			catdatum = hashtab_search(newp->p_cats.table,
						  sym_name(oldp, SYM_CATS, i));
			if (!catdatum)
				return -EINVAL;
			rc = ebitmap_set_bit(&bitmap, catdatum->value - 1, 1);
			if (rc)
				return rc;

			cond_resched();
		}
		ebitmap_destroy(&c->range.level[l].cat);
		c->range.level[l].cat = bitmap;
	}

	return 0;
}

int mls_compute_sid(struct context *scontext,
		    struct context *tcontext,
		    u16 tclass,
		    u32 specified,
		    struct context *newcontext,
		    bool sock)
{
	struct range_trans rtr;
	struct mls_range *r;
	struct class_datum *cladatum;
	int default_range = 0;

	if (!policydb.mls_enabled)
		return 0;

	switch (specified) {
	case AVTAB_TRANSITION:
		/* Look for a range transition rule. */
		rtr.source_type = scontext->type;
		rtr.target_type = tcontext->type;
		rtr.target_class = tclass;
		r = hashtab_search(policydb.range_tr, &rtr);
		if (r)
			return mls_range_set(newcontext, r);

		if (tclass && tclass <= policydb.p_classes.nprim) {
			cladatum = policydb.class_val_to_struct[tclass - 1];
			if (cladatum)
				default_range = cladatum->default_range;
		}

		switch (default_range) {
		case DEFAULT_SOURCE_LOW:
			return mls_context_cpy_low(newcontext, scontext);
		case DEFAULT_SOURCE_HIGH:
			return mls_context_cpy_high(newcontext, scontext);
		case DEFAULT_SOURCE_LOW_HIGH:
			return mls_context_cpy(newcontext, scontext);
		case DEFAULT_TARGET_LOW:
			return mls_context_cpy_low(newcontext, tcontext);
		case DEFAULT_TARGET_HIGH:
			return mls_context_cpy_high(newcontext, tcontext);
		case DEFAULT_TARGET_LOW_HIGH:
			return mls_context_cpy(newcontext, tcontext);
		}

		/* Fallthrough */
	case AVTAB_CHANGE:
		if ((tclass == policydb.process_class) || (sock == true))
			/* Use the process MLS attributes. */
			return mls_context_cpy(newcontext, scontext);
		else
			/* Use the process effective MLS attributes. */
			return mls_context_cpy_low(newcontext, scontext);
	case AVTAB_MEMBER:
		/* Use the process effective MLS attributes. */
		return mls_context_cpy_low(newcontext, scontext);

	/* fall through */
	}
	return -EINVAL;
}

#ifdef CONFIG_NETLABEL
/**
 * mls_export_netlbl_lvl - Export the MLS sensitivity levels to NetLabel
 * @context: the security context
 * @secattr: the NetLabel security attributes
 *
 * Description:
 * Given the security context copy the low MLS sensitivity level into the
 * NetLabel MLS sensitivity level field.
 *
 */
void mls_export_netlbl_lvl(struct context *context,
			   struct netlbl_lsm_secattr *secattr)
{
	if (!policydb.mls_enabled)
		return;

	secattr->attr.mls.lvl = context->range.level[0].sens - 1;
	secattr->flags |= NETLBL_SECATTR_MLS_LVL;
}

/**
 * mls_import_netlbl_lvl - Import the NetLabel MLS sensitivity levels
 * @context: the security context
 * @secattr: the NetLabel security attributes
 *
 * Description:
 * Given the security context and the NetLabel security attributes, copy the
 * NetLabel MLS sensitivity level into the context.
 *
 */
void mls_import_netlbl_lvl(struct context *context,
			   struct netlbl_lsm_secattr *secattr)
{
	if (!policydb.mls_enabled)
		return;

	context->range.level[0].sens = secattr->attr.mls.lvl + 1;
	context->range.level[1].sens = context->range.level[0].sens;
}

/**
 * mls_export_netlbl_cat - Export the MLS categories to NetLabel
 * @context: the security context
 * @secattr: the NetLabel security attributes
 *
 * Description:
 * Given the security context copy the low MLS categories into the NetLabel
 * MLS category field.  Returns zero on success, negative values on failure.
 *
 */
int mls_export_netlbl_cat(struct context *context,
			  struct netlbl_lsm_secattr *secattr)
{
	int rc;

	if (!policydb.mls_enabled)
		return 0;

	rc = ebitmap_netlbl_export(&context->range.level[0].cat,
				   &secattr->attr.mls.cat);
	if (rc == 0 && secattr->attr.mls.cat != NULL)
		secattr->flags |= NETLBL_SECATTR_MLS_CAT;

	return rc;
}

/**
 * mls_import_netlbl_cat - Import the MLS categories from NetLabel
 * @context: the security context
 * @secattr: the NetLabel security attributes
 *
 * Description:
 * Copy the NetLabel security attributes into the SELinux context; since the
 * NetLabel security attribute only contains a single MLS category use it for
 * both the low and high categories of the context.  Returns zero on success,
 * negative values on failure.
 *
 */
int mls_import_netlbl_cat(struct context *context,
			  struct netlbl_lsm_secattr *secattr)
{
	int rc;

	if (!policydb.mls_enabled)
		return 0;

	rc = ebitmap_netlbl_import(&context->range.level[0].cat,
				   secattr->attr.mls.cat);
	if (rc)
		goto import_netlbl_cat_failure;
	memcpy(&context->range.level[1].cat, &context->range.level[0].cat,
	       sizeof(context->range.level[0].cat));

	return 0;

import_netlbl_cat_failure:
	ebitmap_destroy(&context->range.level[0].cat);
	return rc;
}
#endif /* CONFIG_NETLABEL */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Implementation of the multi-level security (MLS) policy.
	3	*
	4	* Author : Stephen Smalley, <sds@epoch.ncsc.mil>
	5	*/
	6	/*
	7	* Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
	8	*
	9	* Support for enhanced MLS infrastructure.
	10	*
376bd9cb	11	* Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
1da177e4	12	*/
7420ed23	13	/*
82c21bfa	14	* Updated: Hewlett-Packard <paul@paul-moore.com>
7420ed23	15	*
02752760	16	* Added support to import/export the MLS label from NetLabel
7420ed23 VY	17	*
	18	* (c) Copyright Hewlett-Packard Development Company, L.P., 2006
	19	*/
1da177e4 LT	20
	21	#include <linux/kernel.h>
	22	#include <linux/slab.h>
	23	#include <linux/string.h>
	24	#include <linux/errno.h>
02752760	25	#include <net/netlabel.h>
f5c1d5b2	26	#include "sidtab.h"
1da177e4 LT	27	#include "mls.h"
	28	#include "policydb.h"
	29	#include "services.h"
	30
	31	/*
	32	* Return the length in bytes for the MLS fields of the
	33	* security context string representation of `context'.
	34	*/
1a5e6f87	35	int mls_compute_context_len(struct context *context)
1da177e4	36	{
9fe79ad1 KK	37	int i, l, len, head, prev;
	38	char *nm;
	39	struct ebitmap *e;
782ebb99	40	struct ebitmap_node *node;
1da177e4	41
0719aaf5	42	if (!policydb.mls_enabled)
1da177e4 LT	43	return 0;
	44
	45	len = 1; /* for the beginning ":" */
	46	for (l = 0; l < 2; l++) {
9fe79ad1	47	int index_sens = context->range.level[l].sens;
ac76c05b	48	len += strlen(sym_name(&policydb, SYM_LEVELS, index_sens - 1));
1da177e4	49
9fe79ad1 KK	50	/* categories */
	51	head = -2;
	52	prev = -2;
	53	e = &context->range.level[l].cat;
	54	ebitmap_for_each_positive_bit(e, node, i) {
	55	if (i - prev > 1) {
	56	/* one or more negative bits are skipped */
	57	if (head != prev) {
ac76c05b	58	nm = sym_name(&policydb, SYM_CATS, prev);
9fe79ad1 KK	59	len += strlen(nm) + 1;
9fe79ad1 KK	60	}
ac76c05b	61	nm = sym_name(&policydb, SYM_CATS, i);
9fe79ad1 KK	62	len += strlen(nm) + 1;
9fe79ad1 KK	63	head = i;
1da177e4	64	}
9fe79ad1 KK	65	prev = i;
	66	}
	67	if (prev != head) {
ac76c05b	68	nm = sym_name(&policydb, SYM_CATS, prev);
9fe79ad1	69	len += strlen(nm) + 1;
1da177e4	70	}
1da177e4 LT	71	if (l == 0) {
1da177e4 LT	72	if (mls_level_eq(&context->range.level[0],
9fe79ad1	73	&context->range.level[1]))
1da177e4 LT	74	break;
	75	else
	76	len++;
	77	}
	78	}
	79
	80	return len;
	81	}
	82
	83	/*
	84	* Write the security context string representation of
	85	* the MLS fields of `context' into the string `*scontext'.
	86	* Update `*scontext' to point to the end of the MLS fields.
	87	*/
	88	void mls_sid_to_context(struct context *context,
1a5e6f87	89	char **scontext)
1da177e4	90	{
9fe79ad1 KK	91	char scontextp, nm;
	92	int i, l, head, prev;
	93	struct ebitmap *e;
782ebb99	94	struct ebitmap_node *node;
1da177e4	95
0719aaf5	96	if (!policydb.mls_enabled)
1da177e4 LT	97	return;
	98
	99	scontextp = *scontext;
	100
	101	*scontextp = ':';
	102	scontextp++;
	103
	104	for (l = 0; l < 2; l++) {
ac76c05b EP	105	strcpy(scontextp, sym_name(&policydb, SYM_LEVELS,
ac76c05b EP	106	context->range.level[l].sens - 1));
9fe79ad1	107	scontextp += strlen(scontextp);
1da177e4 LT	108
1da177e4 LT	109	/* categories */
9fe79ad1 KK	110	head = -2;
	111	prev = -2;
	112	e = &context->range.level[l].cat;
	113	ebitmap_for_each_positive_bit(e, node, i) {
	114	if (i - prev > 1) {
	115	/* one or more negative bits are skipped */
	116	if (prev != head) {
	117	if (prev - head > 1)
1da177e4 LT	118	*scontextp++ = '.';
	119	else
	120	*scontextp++ = ',';
ac76c05b	121	nm = sym_name(&policydb, SYM_CATS, prev);
9fe79ad1 KK	122	strcpy(scontextp, nm);
9fe79ad1 KK	123	scontextp += strlen(nm);
1da177e4	124	}
9fe79ad1 KK	125	if (prev < 0)
	126	*scontextp++ = ':';
	127	else
	128	*scontextp++ = ',';
ac76c05b	129	nm = sym_name(&policydb, SYM_CATS, i);
9fe79ad1 KK	130	strcpy(scontextp, nm);
	131	scontextp += strlen(nm);
	132	head = i;
1da177e4	133	}
9fe79ad1	134	prev = i;
1da177e4 LT	135	}
1da177e4 LT	136
9fe79ad1 KK	137	if (prev != head) {
9fe79ad1 KK	138	if (prev - head > 1)
1da177e4 LT	139	*scontextp++ = '.';
	140	else
	141	*scontextp++ = ',';
ac76c05b	142	nm = sym_name(&policydb, SYM_CATS, prev);
9fe79ad1 KK	143	strcpy(scontextp, nm);
9fe79ad1 KK	144	scontextp += strlen(nm);
1da177e4 LT	145	}
	146
	147	if (l == 0) {
	148	if (mls_level_eq(&context->range.level[0],
1a5e6f87	149	&context->range.level[1]))
1da177e4	150	break;
9fe79ad1 KK	151	else
9fe79ad1 KK	152	*scontextp++ = '-';
1da177e4 LT	153	}
	154	}
	155
	156	*scontext = scontextp;
	157	return;
	158	}
	159
45e5421e SS	160	int mls_level_isvalid(struct policydb p, struct mls_level l)
	161	{
	162	struct level_datum *levdatum;
45e5421e SS	163
	164	if (!l->sens \|\| l->sens > p->p_levels.nprim)
	165	return 0;
	166	levdatum = hashtab_search(p->p_levels.table,
ac76c05b	167	sym_name(p, SYM_LEVELS, l->sens - 1));
45e5421e SS	168	if (!levdatum)
	169	return 0;
	170
fee71142 WL	171	/*
	172	* Return 1 iff all the bits set in l->cat are also be set in
	173	* levdatum->level->cat and no bit in l->cat is larger than
	174	* p->p_cats.nprim.
	175	*/
	176	return ebitmap_contains(&levdatum->level->cat, &l->cat,
	177	p->p_cats.nprim);
45e5421e SS	178	}
	179
	180	int mls_range_isvalid(struct policydb p, struct mls_range r)
	181	{
	182	return (mls_level_isvalid(p, &r->level[0]) &&
	183	mls_level_isvalid(p, &r->level[1]) &&
	184	mls_level_dom(&r->level[1], &r->level[0]));
	185	}
	186
1da177e4 LT	187	/*
	188	* Return 1 if the MLS fields in the security context
	189	* structure `c' are valid. Return 0 otherwise.
	190	*/
	191	int mls_context_isvalid(struct policydb p, struct context c)
	192	{
1da177e4	193	struct user_datum *usrdatum;
1da177e4	194
0719aaf5	195	if (!p->mls_enabled)
1da177e4 LT	196	return 1;
1da177e4 LT	197
45e5421e	198	if (!mls_range_isvalid(p, &c->range))
1da177e4 LT	199	return 0;
1da177e4 LT	200
1da177e4 LT	201	if (c->role == OBJECT_R_VAL)
	202	return 1;
	203
	204	/*
	205	* User must be authorized for the MLS range.
	206	*/
	207	if (!c->user \|\| c->user > p->p_users.nprim)
	208	return 0;
	209	usrdatum = p->user_val_to_struct[c->user - 1];
	210	if (!mls_range_contains(usrdatum->range, c->range))
	211	return 0; /* user may not be associated with range */
	212
	213	return 1;
	214	}
	215
	216	/*
	217	* Set the MLS fields in the security context structure
	218	* `context' based on the string representation in
	219	* the string `scontext'. Update `scontext' to
	220	* point to the end of the string representation of
	221	* the MLS fields.
	222	*
	223	* This function modifies the string in place, inserting
	224	* NULL characters to terminate the MLS fields.
f5c1d5b2 JM	225	*
	226	* If a def_sid is provided and no MLS field is present,
	227	* copy the MLS field of the associated default context.
	228	* Used for upgraded to MLS systems where objects may lack
	229	* MLS fields.
	230	*
	231	* Policy read-lock must be held for sidtab lookup.
	232	*
1da177e4	233	*/
12b29f34 SS	234	int mls_context_to_sid(struct policydb *pol,
12b29f34 SS	235	char oldc,
1da177e4	236	char **scontext,
f5c1d5b2 JM	237	struct context *context,
	238	struct sidtab *s,
	239	u32 def_sid)
1da177e4 LT	240	{
	241
	242	char delim;
	243	char scontextp, p, *rngptr;
	244	struct level_datum *levdatum;
	245	struct cat_datum catdatum, rngdatum;
	246	int l, rc = -EINVAL;
	247
0719aaf5	248	if (!pol->mls_enabled) {
e517a0cd	249	if (def_sid != SECSID_NULL && oldc)
c1a7368a	250	scontext += strlen(scontext) + 1;
1da177e4	251	return 0;
e517a0cd	252	}
1da177e4	253
f5c1d5b2 JM	254	/*
	255	* No MLS component to the security context, try and map to
	256	* default if provided.
	257	*/
	258	if (!oldc) {
	259	struct context *defcon;
	260
	261	if (def_sid == SECSID_NULL)
	262	goto out;
	263
	264	defcon = sidtab_search(s, def_sid);
	265	if (!defcon)
	266	goto out;
	267
0efc61ea	268	rc = mls_context_cpy(context, defcon);
1da177e4	269	goto out;
f5c1d5b2	270	}
1da177e4 LT	271
	272	/* Extract low sensitivity. */
	273	scontextp = p = *scontext;
	274	while (p && p != ':' && *p != '-')
	275	p++;
	276
	277	delim = *p;
df4ea865 VMK	278	if (delim != '\0')
df4ea865 VMK	279	*p++ = '\0';
1da177e4 LT	280
1da177e4 LT	281	for (l = 0; l < 2; l++) {
12b29f34	282	levdatum = hashtab_search(pol->p_levels.table, scontextp);
1da177e4 LT	283	if (!levdatum) {
	284	rc = -EINVAL;
	285	goto out;
	286	}
	287
	288	context->range.level[l].sens = levdatum->level->sens;
	289
	290	if (delim == ':') {
	291	/* Extract category set. */
	292	while (1) {
	293	scontextp = p;
	294	while (p && p != ',' && *p != '-')
	295	p++;
	296	delim = *p;
df4ea865 VMK	297	if (delim != '\0')
df4ea865 VMK	298	*p++ = '\0';
1da177e4 LT	299
1da177e4 LT	300	/* Separate into range if exists */
1a5e6f87 EP	301	rngptr = strchr(scontextp, '.');
1a5e6f87 EP	302	if (rngptr != NULL) {
1da177e4	303	/* Remove '.' */
df4ea865	304	*rngptr++ = '\0';
1da177e4 LT	305	}
1da177e4 LT	306
12b29f34	307	catdatum = hashtab_search(pol->p_cats.table,
1a5e6f87	308	scontextp);
1da177e4 LT	309	if (!catdatum) {
	310	rc = -EINVAL;
	311	goto out;
	312	}
	313
	314	rc = ebitmap_set_bit(&context->range.level[l].cat,
1a5e6f87	315	catdatum->value - 1, 1);
1da177e4 LT	316	if (rc)
	317	goto out;
	318
	319	/* If range, set all categories in range */
	320	if (rngptr) {
	321	int i;
	322
12b29f34	323	rngdatum = hashtab_search(pol->p_cats.table, rngptr);
1da177e4 LT	324	if (!rngdatum) {
	325	rc = -EINVAL;
	326	goto out;
	327	}
	328
	329	if (catdatum->value >= rngdatum->value) {
	330	rc = -EINVAL;
	331	goto out;
	332	}
	333
	334	for (i = catdatum->value; i < rngdatum->value; i++) {
	335	rc = ebitmap_set_bit(&context->range.level[l].cat, i, 1);
	336	if (rc)
	337	goto out;
	338	}
	339	}
	340
	341	if (delim != ',')
	342	break;
	343	}
	344	}
	345	if (delim == '-') {
	346	/* Extract high sensitivity. */
	347	scontextp = p;
	348	while (p && p != ':')
	349	p++;
	350
	351	delim = *p;
df4ea865 VMK	352	if (delim != '\0')
df4ea865 VMK	353	*p++ = '\0';
1da177e4 LT	354	} else
	355	break;
	356	}
	357
	358	if (l == 0) {
	359	context->range.level[1].sens = context->range.level[0].sens;
	360	rc = ebitmap_cpy(&context->range.level[1].cat,
	361	&context->range.level[0].cat);
	362	if (rc)
	363	goto out;
	364	}
	365	*scontext = ++p;
	366	rc = 0;
	367	out:
	368	return rc;
	369	}
	370
376bd9cb DG	371	/*
	372	* Set the MLS fields in the security context structure
	373	* `context' based on the string representation in
	374	* the string `str'. This function will allocate temporary memory with the
	375	* given constraints of gfp_mask.
	376	*/
	377	int mls_from_string(char str, struct context context, gfp_t gfp_mask)
	378	{
	379	char tmpstr, freestr;
	380	int rc;
	381
0719aaf5	382	if (!policydb.mls_enabled)
376bd9cb DG	383	return -EINVAL;
	384
	385	/* we need freestr because mls_context_to_sid will change
	386	the value of tmpstr */
	387	tmpstr = freestr = kstrdup(str, gfp_mask);
	388	if (!tmpstr) {
	389	rc = -ENOMEM;
	390	} else {
12b29f34	391	rc = mls_context_to_sid(&policydb, ':', &tmpstr, context,
1a5e6f87	392	NULL, SECSID_NULL);
376bd9cb DG	393	kfree(freestr);
	394	}
	395
	396	return rc;
	397	}
	398
1da177e4 LT	399	/*
	400	* Copies the MLS range `range' into `context'.
	401	*/
0719aaf5	402	int mls_range_set(struct context *context,
1a5e6f87	403	struct mls_range *range)
1da177e4 LT	404	{
	405	int l, rc = 0;
	406
	407	/* Copy the MLS range into the context */
	408	for (l = 0; l < 2; l++) {
	409	context->range.level[l].sens = range->level[l].sens;
	410	rc = ebitmap_cpy(&context->range.level[l].cat,
	411	&range->level[l].cat);
	412	if (rc)
	413	break;
	414	}
	415
	416	return rc;
	417	}
	418
	419	int mls_setup_user_range(struct context fromcon, struct user_datum user,
1a5e6f87	420	struct context *usercon)
1da177e4	421	{
0719aaf5	422	if (policydb.mls_enabled) {
1da177e4 LT	423	struct mls_level *fromcon_sen = &(fromcon->range.level[0]);
	424	struct mls_level *fromcon_clr = &(fromcon->range.level[1]);
	425	struct mls_level *user_low = &(user->range.level[0]);
	426	struct mls_level *user_clr = &(user->range.level[1]);
	427	struct mls_level *user_def = &(user->dfltlevel);
	428	struct mls_level *usercon_sen = &(usercon->range.level[0]);
	429	struct mls_level *usercon_clr = &(usercon->range.level[1]);
	430
	431	/* Honor the user's default level if we can */
f5269710	432	if (mls_level_between(user_def, fromcon_sen, fromcon_clr))
1da177e4	433	usercon_sen = user_def;
f5269710	434	else if (mls_level_between(fromcon_sen, user_def, user_clr))
1da177e4	435	usercon_sen = fromcon_sen;
f5269710	436	else if (mls_level_between(fromcon_clr, user_low, user_def))
1da177e4	437	usercon_sen = user_low;
f5269710	438	else
1da177e4 LT	439	return -EINVAL;
	440
	441	/* Lower the clearance of available contexts
	442	if the clearance of "fromcon" is lower than
	443	that of the user's default clearance (but
	444	only if the "fromcon" clearance dominates
	445	the user's computed sensitivity level) */
1a5e6f87	446	if (mls_level_dom(user_clr, fromcon_clr))
1da177e4	447	usercon_clr = fromcon_clr;
1a5e6f87	448	else if (mls_level_dom(fromcon_clr, user_clr))
1da177e4	449	usercon_clr = user_clr;
1a5e6f87	450	else
1da177e4 LT	451	return -EINVAL;
	452	}
	453
	454	return 0;
	455	}
	456
	457	/*
	458	* Convert the MLS fields in the security context
	459	* structure `c' from the values specified in the
	460	* policy `oldp' to the values specified in the policy `newp'.
	461	*/
	462	int mls_convert_context(struct policydb *oldp,
	463	struct policydb *newp,
	464	struct context *c)
	465	{
	466	struct level_datum *levdatum;
	467	struct cat_datum *catdatum;
	468	struct ebitmap bitmap;
782ebb99	469	struct ebitmap_node *node;
1da177e4 LT	470	int l, i;
1da177e4 LT	471
0719aaf5	472	if (!policydb.mls_enabled)
1da177e4 LT	473	return 0;
	474
	475	for (l = 0; l < 2; l++) {
	476	levdatum = hashtab_search(newp->p_levels.table,
ac76c05b EP	477	sym_name(oldp, SYM_LEVELS,
ac76c05b EP	478	c->range.level[l].sens - 1));
1da177e4 LT	479
	480	if (!levdatum)
	481	return -EINVAL;
	482	c->range.level[l].sens = levdatum->level->sens;
	483
	484	ebitmap_init(&bitmap);
9fe79ad1 KK	485	ebitmap_for_each_positive_bit(&c->range.level[l].cat, node, i) {
	486	int rc;
	487
	488	catdatum = hashtab_search(newp->p_cats.table,
ac76c05b	489	sym_name(oldp, SYM_CATS, i));
9fe79ad1 KK	490	if (!catdatum)
	491	return -EINVAL;
	492	rc = ebitmap_set_bit(&bitmap, catdatum->value - 1, 1);
	493	if (rc)
	494	return rc;
9a591f39 DJ	495
9a591f39 DJ	496	cond_resched();
1da177e4 LT	497	}
	498	ebitmap_destroy(&c->range.level[l].cat);
	499	c->range.level[l].cat = bitmap;
	500	}
	501
	502	return 0;
	503	}
	504
	505	int mls_compute_sid(struct context *scontext,
	506	struct context *tcontext,
	507	u16 tclass,
	508	u32 specified,
6f5317e7 HC	509	struct context *newcontext,
6f5317e7 HC	510	bool sock)
1da177e4	511	{
2f3e82d6 SS	512	struct range_trans rtr;
2f3e82d6 SS	513	struct mls_range *r;
aa893269 EP	514	struct class_datum *cladatum;
aa893269 EP	515	int default_range = 0;
f3f87714	516
0719aaf5	517	if (!policydb.mls_enabled)
1da177e4 LT	518	return 0;
	519
	520	switch (specified) {
	521	case AVTAB_TRANSITION:
f3f87714	522	/* Look for a range transition rule. */
2f3e82d6 SS	523	rtr.source_type = scontext->type;
	524	rtr.target_type = tcontext->type;
	525	rtr.target_class = tclass;
	526	r = hashtab_search(policydb.range_tr, &rtr);
	527	if (r)
	528	return mls_range_set(newcontext, r);
aa893269 EP	529
	530	if (tclass && tclass <= policydb.p_classes.nprim) {
	531	cladatum = policydb.class_val_to_struct[tclass - 1];
	532	if (cladatum)
	533	default_range = cladatum->default_range;
	534	}
	535
	536	switch (default_range) {
	537	case DEFAULT_SOURCE_LOW:
	538	return mls_context_cpy_low(newcontext, scontext);
	539	case DEFAULT_SOURCE_HIGH:
	540	return mls_context_cpy_high(newcontext, scontext);
	541	case DEFAULT_SOURCE_LOW_HIGH:
	542	return mls_context_cpy(newcontext, scontext);
	543	case DEFAULT_TARGET_LOW:
	544	return mls_context_cpy_low(newcontext, tcontext);
	545	case DEFAULT_TARGET_HIGH:
	546	return mls_context_cpy_high(newcontext, tcontext);
	547	case DEFAULT_TARGET_LOW_HIGH:
	548	return mls_context_cpy(newcontext, tcontext);
	549	}
	550
1da177e4 LT	551	/* Fallthrough */
1da177e4 LT	552	case AVTAB_CHANGE:
6f5317e7	553	if ((tclass == policydb.process_class) \|\| (sock == true))
1da177e4	554	/* Use the process MLS attributes. */
0efc61ea	555	return mls_context_cpy(newcontext, scontext);
1da177e4 LT	556	else
1da177e4 LT	557	/* Use the process effective MLS attributes. */
0efc61ea	558	return mls_context_cpy_low(newcontext, scontext);
1da177e4	559	case AVTAB_MEMBER:
2e08c0c1 EW	560	/* Use the process effective MLS attributes. */
2e08c0c1 EW	561	return mls_context_cpy_low(newcontext, scontext);
08e3daff AW	562
08e3daff AW	563	/* fall through */
1da177e4 LT	564	}
	565	return -EINVAL;
	566	}
	567
02752760	568	#ifdef CONFIG_NETLABEL
7420ed23	569	/**
02752760	570	* mls_export_netlbl_lvl - Export the MLS sensitivity levels to NetLabel
7420ed23	571	* @context: the security context
02752760	572	* @secattr: the NetLabel security attributes
7420ed23 VY	573	*
7420ed23 VY	574	* Description:
02752760 PM	575	* Given the security context copy the low MLS sensitivity level into the
02752760 PM	576	* NetLabel MLS sensitivity level field.
7420ed23 VY	577	*
7420ed23 VY	578	*/
02752760 PM	579	void mls_export_netlbl_lvl(struct context *context,
02752760 PM	580	struct netlbl_lsm_secattr *secattr)
7420ed23	581	{
0719aaf5	582	if (!policydb.mls_enabled)
7420ed23 VY	583	return;
7420ed23 VY	584
16efd454	585	secattr->attr.mls.lvl = context->range.level[0].sens - 1;
02752760	586	secattr->flags \|= NETLBL_SECATTR_MLS_LVL;
7420ed23 VY	587	}
	588
	589	/**
02752760	590	* mls_import_netlbl_lvl - Import the NetLabel MLS sensitivity levels
7420ed23	591	* @context: the security context
02752760	592	* @secattr: the NetLabel security attributes
7420ed23 VY	593	*
7420ed23 VY	594	* Description:
02752760 PM	595	* Given the security context and the NetLabel security attributes, copy the
02752760 PM	596	* NetLabel MLS sensitivity level into the context.
7420ed23 VY	597	*
7420ed23 VY	598	*/
02752760 PM	599	void mls_import_netlbl_lvl(struct context *context,
02752760 PM	600	struct netlbl_lsm_secattr *secattr)
7420ed23	601	{
0719aaf5	602	if (!policydb.mls_enabled)
7420ed23 VY	603	return;
7420ed23 VY	604
16efd454	605	context->range.level[0].sens = secattr->attr.mls.lvl + 1;
02752760	606	context->range.level[1].sens = context->range.level[0].sens;
7420ed23 VY	607	}
	608
	609	/**
02752760	610	* mls_export_netlbl_cat - Export the MLS categories to NetLabel
7420ed23	611	* @context: the security context
02752760	612	* @secattr: the NetLabel security attributes
7420ed23 VY	613	*
7420ed23 VY	614	* Description:
02752760 PM	615	* Given the security context copy the low MLS categories into the NetLabel
02752760 PM	616	* MLS category field. Returns zero on success, negative values on failure.
7420ed23 VY	617	*
7420ed23 VY	618	*/
02752760 PM	619	int mls_export_netlbl_cat(struct context *context,
02752760 PM	620	struct netlbl_lsm_secattr *secattr)
7420ed23	621	{
02752760	622	int rc;
7420ed23	623
0719aaf5	624	if (!policydb.mls_enabled)
7420ed23 VY	625	return 0;
7420ed23 VY	626
02752760	627	rc = ebitmap_netlbl_export(&context->range.level[0].cat,
16efd454 PM	628	&secattr->attr.mls.cat);
16efd454 PM	629	if (rc == 0 && secattr->attr.mls.cat != NULL)
02752760	630	secattr->flags \|= NETLBL_SECATTR_MLS_CAT;
7420ed23	631
7420ed23 VY	632	return rc;
	633	}
	634
	635	/**
02752760	636	* mls_import_netlbl_cat - Import the MLS categories from NetLabel
7420ed23	637	* @context: the security context
02752760	638	* @secattr: the NetLabel security attributes
7420ed23 VY	639	*
7420ed23 VY	640	* Description:
02752760 PM	641	* Copy the NetLabel security attributes into the SELinux context; since the
	642	* NetLabel security attribute only contains a single MLS category use it for
	643	* both the low and high categories of the context. Returns zero on success,
	644	* negative values on failure.
7420ed23 VY	645	*
7420ed23 VY	646	*/
02752760 PM	647	int mls_import_netlbl_cat(struct context *context,
02752760 PM	648	struct netlbl_lsm_secattr *secattr)
7420ed23	649	{
02752760	650	int rc;
7420ed23	651
0719aaf5	652	if (!policydb.mls_enabled)
7420ed23 VY	653	return 0;
7420ed23 VY	654
02752760	655	rc = ebitmap_netlbl_import(&context->range.level[0].cat,
16efd454	656	secattr->attr.mls.cat);
da8026fa	657	if (rc)
02752760	658	goto import_netlbl_cat_failure;
da8026fa PM	659	memcpy(&context->range.level[1].cat, &context->range.level[0].cat,
da8026fa PM	660	sizeof(context->range.level[0].cat));
7420ed23 VY	661
	662	return 0;
	663
02752760	664	import_netlbl_cat_failure:
7420ed23	665	ebitmap_destroy(&context->range.level[0].cat);
7420ed23 VY	666	return rc;
7420ed23 VY	667	}
02752760	668	#endif /* CONFIG_NETLABEL */