Linux Audio

Check our new training course

Loading...
v5.4
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Implementation of the kernel access vector cache (AVC).
   4 *
   5 * Authors:  Stephen Smalley, <sds@tycho.nsa.gov>
   6 *	     James Morris <jmorris@redhat.com>
   7 *
   8 * Update:   KaiGai, Kohei <kaigai@ak.jp.nec.com>
   9 *	Replaced the avc_lock spinlock by RCU.
  10 *
  11 * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
  12 */
  13#include <linux/types.h>
  14#include <linux/stddef.h>
  15#include <linux/kernel.h>
  16#include <linux/slab.h>
  17#include <linux/fs.h>
  18#include <linux/dcache.h>
  19#include <linux/init.h>
  20#include <linux/skbuff.h>
  21#include <linux/percpu.h>
  22#include <linux/list.h>
  23#include <net/sock.h>
  24#include <linux/un.h>
  25#include <net/af_unix.h>
  26#include <linux/ip.h>
  27#include <linux/audit.h>
  28#include <linux/ipv6.h>
  29#include <net/ipv6.h>
  30#include "avc.h"
  31#include "avc_ss.h"
  32#include "classmap.h"
  33
 
 
 
  34#define AVC_CACHE_SLOTS			512
  35#define AVC_DEF_CACHE_THRESHOLD		512
  36#define AVC_CACHE_RECLAIM		16
  37
  38#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
  39#define avc_cache_stats_incr(field)	this_cpu_inc(avc_cache_stats.field)
  40#else
  41#define avc_cache_stats_incr(field)	do {} while (0)
  42#endif
  43
  44struct avc_entry {
  45	u32			ssid;
  46	u32			tsid;
  47	u16			tclass;
  48	struct av_decision	avd;
  49	struct avc_xperms_node	*xp_node;
  50};
  51
  52struct avc_node {
  53	struct avc_entry	ae;
  54	struct hlist_node	list; /* anchored in avc_cache->slots[i] */
  55	struct rcu_head		rhead;
  56};
  57
  58struct avc_xperms_decision_node {
  59	struct extended_perms_decision xpd;
  60	struct list_head xpd_list; /* list of extended_perms_decision */
  61};
  62
  63struct avc_xperms_node {
  64	struct extended_perms xp;
  65	struct list_head xpd_head; /* list head of extended_perms_decision */
  66};
  67
  68struct avc_cache {
  69	struct hlist_head	slots[AVC_CACHE_SLOTS]; /* head for avc_node->list */
  70	spinlock_t		slots_lock[AVC_CACHE_SLOTS]; /* lock for writes */
  71	atomic_t		lru_hint;	/* LRU hint for reclaim scan */
  72	atomic_t		active_nodes;
  73	u32			latest_notif;	/* latest revocation notification */
  74};
  75
  76struct avc_callback_node {
  77	int (*callback) (u32 event);
  78	u32 events;
  79	struct avc_callback_node *next;
  80};
  81
  82#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
  83DEFINE_PER_CPU(struct avc_cache_stats, avc_cache_stats) = { 0 };
  84#endif
  85
  86struct selinux_avc {
  87	unsigned int avc_cache_threshold;
  88	struct avc_cache avc_cache;
  89};
  90
  91static struct selinux_avc selinux_avc;
  92
  93void selinux_avc_init(struct selinux_avc **avc)
  94{
  95	int i;
  96
  97	selinux_avc.avc_cache_threshold = AVC_DEF_CACHE_THRESHOLD;
  98	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
  99		INIT_HLIST_HEAD(&selinux_avc.avc_cache.slots[i]);
 100		spin_lock_init(&selinux_avc.avc_cache.slots_lock[i]);
 101	}
 102	atomic_set(&selinux_avc.avc_cache.active_nodes, 0);
 103	atomic_set(&selinux_avc.avc_cache.lru_hint, 0);
 104	*avc = &selinux_avc;
 105}
 106
 107unsigned int avc_get_cache_threshold(struct selinux_avc *avc)
 108{
 109	return avc->avc_cache_threshold;
 110}
 111
 112void avc_set_cache_threshold(struct selinux_avc *avc,
 113			     unsigned int cache_threshold)
 114{
 115	avc->avc_cache_threshold = cache_threshold;
 116}
 117
 118static struct avc_callback_node *avc_callbacks;
 119static struct kmem_cache *avc_node_cachep;
 120static struct kmem_cache *avc_xperms_data_cachep;
 121static struct kmem_cache *avc_xperms_decision_cachep;
 122static struct kmem_cache *avc_xperms_cachep;
 123
 124static inline int avc_hash(u32 ssid, u32 tsid, u16 tclass)
 125{
 126	return (ssid ^ (tsid<<2) ^ (tclass<<4)) & (AVC_CACHE_SLOTS - 1);
 127}
 128
 129/**
 130 * avc_init - Initialize the AVC.
 131 *
 132 * Initialize the access vector cache.
 133 */
 134void __init avc_init(void)
 135{
 136	avc_node_cachep = kmem_cache_create("avc_node", sizeof(struct avc_node),
 137					0, SLAB_PANIC, NULL);
 138	avc_xperms_cachep = kmem_cache_create("avc_xperms_node",
 139					sizeof(struct avc_xperms_node),
 140					0, SLAB_PANIC, NULL);
 141	avc_xperms_decision_cachep = kmem_cache_create(
 142					"avc_xperms_decision_node",
 143					sizeof(struct avc_xperms_decision_node),
 144					0, SLAB_PANIC, NULL);
 145	avc_xperms_data_cachep = kmem_cache_create("avc_xperms_data",
 146					sizeof(struct extended_perms_data),
 147					0, SLAB_PANIC, NULL);
 148}
 149
 150int avc_get_hash_stats(struct selinux_avc *avc, char *page)
 151{
 152	int i, chain_len, max_chain_len, slots_used;
 153	struct avc_node *node;
 154	struct hlist_head *head;
 155
 156	rcu_read_lock();
 157
 158	slots_used = 0;
 159	max_chain_len = 0;
 160	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
 161		head = &avc->avc_cache.slots[i];
 162		if (!hlist_empty(head)) {
 163			slots_used++;
 164			chain_len = 0;
 165			hlist_for_each_entry_rcu(node, head, list)
 166				chain_len++;
 167			if (chain_len > max_chain_len)
 168				max_chain_len = chain_len;
 169		}
 170	}
 171
 172	rcu_read_unlock();
 173
 174	return scnprintf(page, PAGE_SIZE, "entries: %d\nbuckets used: %d/%d\n"
 175			 "longest chain: %d\n",
 176			 atomic_read(&avc->avc_cache.active_nodes),
 177			 slots_used, AVC_CACHE_SLOTS, max_chain_len);
 178}
 179
 180/*
 181 * using a linked list for extended_perms_decision lookup because the list is
 182 * always small. i.e. less than 5, typically 1
 183 */
 184static struct extended_perms_decision *avc_xperms_decision_lookup(u8 driver,
 185					struct avc_xperms_node *xp_node)
 
 186{
 187	struct avc_xperms_decision_node *xpd_node;
 188
 189	list_for_each_entry(xpd_node, &xp_node->xpd_head, xpd_list) {
 190		if (xpd_node->xpd.driver == driver)
 
 191			return &xpd_node->xpd;
 192	}
 193	return NULL;
 194}
 195
 196static inline unsigned int
 197avc_xperms_has_perm(struct extended_perms_decision *xpd,
 198					u8 perm, u8 which)
 199{
 200	unsigned int rc = 0;
 201
 202	if ((which == XPERMS_ALLOWED) &&
 203			(xpd->used & XPERMS_ALLOWED))
 204		rc = security_xperm_test(xpd->allowed->p, perm);
 205	else if ((which == XPERMS_AUDITALLOW) &&
 206			(xpd->used & XPERMS_AUDITALLOW))
 207		rc = security_xperm_test(xpd->auditallow->p, perm);
 208	else if ((which == XPERMS_DONTAUDIT) &&
 209			(xpd->used & XPERMS_DONTAUDIT))
 210		rc = security_xperm_test(xpd->dontaudit->p, perm);
 211	return rc;
 212}
 213
 214static void avc_xperms_allow_perm(struct avc_xperms_node *xp_node,
 215				u8 driver, u8 perm)
 216{
 217	struct extended_perms_decision *xpd;
 218	security_xperm_set(xp_node->xp.drivers.p, driver);
 219	xpd = avc_xperms_decision_lookup(driver, xp_node);
 
 220	if (xpd && xpd->allowed)
 221		security_xperm_set(xpd->allowed->p, perm);
 222}
 223
 224static void avc_xperms_decision_free(struct avc_xperms_decision_node *xpd_node)
 225{
 226	struct extended_perms_decision *xpd;
 227
 228	xpd = &xpd_node->xpd;
 229	if (xpd->allowed)
 230		kmem_cache_free(avc_xperms_data_cachep, xpd->allowed);
 231	if (xpd->auditallow)
 232		kmem_cache_free(avc_xperms_data_cachep, xpd->auditallow);
 233	if (xpd->dontaudit)
 234		kmem_cache_free(avc_xperms_data_cachep, xpd->dontaudit);
 235	kmem_cache_free(avc_xperms_decision_cachep, xpd_node);
 236}
 237
 238static void avc_xperms_free(struct avc_xperms_node *xp_node)
 239{
 240	struct avc_xperms_decision_node *xpd_node, *tmp;
 241
 242	if (!xp_node)
 243		return;
 244
 245	list_for_each_entry_safe(xpd_node, tmp, &xp_node->xpd_head, xpd_list) {
 246		list_del(&xpd_node->xpd_list);
 247		avc_xperms_decision_free(xpd_node);
 248	}
 249	kmem_cache_free(avc_xperms_cachep, xp_node);
 250}
 251
 252static void avc_copy_xperms_decision(struct extended_perms_decision *dest,
 253					struct extended_perms_decision *src)
 254{
 
 255	dest->driver = src->driver;
 256	dest->used = src->used;
 257	if (dest->used & XPERMS_ALLOWED)
 258		memcpy(dest->allowed->p, src->allowed->p,
 259				sizeof(src->allowed->p));
 260	if (dest->used & XPERMS_AUDITALLOW)
 261		memcpy(dest->auditallow->p, src->auditallow->p,
 262				sizeof(src->auditallow->p));
 263	if (dest->used & XPERMS_DONTAUDIT)
 264		memcpy(dest->dontaudit->p, src->dontaudit->p,
 265				sizeof(src->dontaudit->p));
 266}
 267
 268/*
 269 * similar to avc_copy_xperms_decision, but only copy decision
 270 * information relevant to this perm
 271 */
 272static inline void avc_quick_copy_xperms_decision(u8 perm,
 273			struct extended_perms_decision *dest,
 274			struct extended_perms_decision *src)
 275{
 276	/*
 277	 * compute index of the u32 of the 256 bits (8 u32s) that contain this
 278	 * command permission
 279	 */
 280	u8 i = perm >> 5;
 281
 
 282	dest->used = src->used;
 283	if (dest->used & XPERMS_ALLOWED)
 284		dest->allowed->p[i] = src->allowed->p[i];
 285	if (dest->used & XPERMS_AUDITALLOW)
 286		dest->auditallow->p[i] = src->auditallow->p[i];
 287	if (dest->used & XPERMS_DONTAUDIT)
 288		dest->dontaudit->p[i] = src->dontaudit->p[i];
 289}
 290
 291static struct avc_xperms_decision_node
 292		*avc_xperms_decision_alloc(u8 which)
 293{
 294	struct avc_xperms_decision_node *xpd_node;
 295	struct extended_perms_decision *xpd;
 296
 297	xpd_node = kmem_cache_zalloc(avc_xperms_decision_cachep, GFP_NOWAIT);
 
 298	if (!xpd_node)
 299		return NULL;
 300
 301	xpd = &xpd_node->xpd;
 302	if (which & XPERMS_ALLOWED) {
 303		xpd->allowed = kmem_cache_zalloc(avc_xperms_data_cachep,
 304						GFP_NOWAIT);
 305		if (!xpd->allowed)
 306			goto error;
 307	}
 308	if (which & XPERMS_AUDITALLOW) {
 309		xpd->auditallow = kmem_cache_zalloc(avc_xperms_data_cachep,
 310						GFP_NOWAIT);
 311		if (!xpd->auditallow)
 312			goto error;
 313	}
 314	if (which & XPERMS_DONTAUDIT) {
 315		xpd->dontaudit = kmem_cache_zalloc(avc_xperms_data_cachep,
 316						GFP_NOWAIT);
 317		if (!xpd->dontaudit)
 318			goto error;
 319	}
 320	return xpd_node;
 321error:
 322	avc_xperms_decision_free(xpd_node);
 323	return NULL;
 324}
 325
 326static int avc_add_xperms_decision(struct avc_node *node,
 327			struct extended_perms_decision *src)
 328{
 329	struct avc_xperms_decision_node *dest_xpd;
 330
 331	node->ae.xp_node->xp.len++;
 332	dest_xpd = avc_xperms_decision_alloc(src->used);
 333	if (!dest_xpd)
 334		return -ENOMEM;
 335	avc_copy_xperms_decision(&dest_xpd->xpd, src);
 336	list_add(&dest_xpd->xpd_list, &node->ae.xp_node->xpd_head);
 
 337	return 0;
 338}
 339
 340static struct avc_xperms_node *avc_xperms_alloc(void)
 341{
 342	struct avc_xperms_node *xp_node;
 343
 344	xp_node = kmem_cache_zalloc(avc_xperms_cachep, GFP_NOWAIT);
 345	if (!xp_node)
 346		return xp_node;
 347	INIT_LIST_HEAD(&xp_node->xpd_head);
 348	return xp_node;
 349}
 350
 351static int avc_xperms_populate(struct avc_node *node,
 352				struct avc_xperms_node *src)
 353{
 354	struct avc_xperms_node *dest;
 355	struct avc_xperms_decision_node *dest_xpd;
 356	struct avc_xperms_decision_node *src_xpd;
 357
 358	if (src->xp.len == 0)
 359		return 0;
 360	dest = avc_xperms_alloc();
 361	if (!dest)
 362		return -ENOMEM;
 363
 364	memcpy(dest->xp.drivers.p, src->xp.drivers.p, sizeof(dest->xp.drivers.p));
 365	dest->xp.len = src->xp.len;
 
 366
 367	/* for each source xpd allocate a destination xpd and copy */
 368	list_for_each_entry(src_xpd, &src->xpd_head, xpd_list) {
 369		dest_xpd = avc_xperms_decision_alloc(src_xpd->xpd.used);
 370		if (!dest_xpd)
 371			goto error;
 372		avc_copy_xperms_decision(&dest_xpd->xpd, &src_xpd->xpd);
 373		list_add(&dest_xpd->xpd_list, &dest->xpd_head);
 374	}
 375	node->ae.xp_node = dest;
 376	return 0;
 377error:
 378	avc_xperms_free(dest);
 379	return -ENOMEM;
 380
 381}
 382
 383static inline u32 avc_xperms_audit_required(u32 requested,
 384					struct av_decision *avd,
 385					struct extended_perms_decision *xpd,
 386					u8 perm,
 387					int result,
 388					u32 *deniedp)
 389{
 390	u32 denied, audited;
 391
 392	denied = requested & ~avd->allowed;
 393	if (unlikely(denied)) {
 394		audited = denied & avd->auditdeny;
 395		if (audited && xpd) {
 396			if (avc_xperms_has_perm(xpd, perm, XPERMS_DONTAUDIT))
 397				audited &= ~requested;
 398		}
 399	} else if (result) {
 400		audited = denied = requested;
 401	} else {
 402		audited = requested & avd->auditallow;
 403		if (audited && xpd) {
 404			if (!avc_xperms_has_perm(xpd, perm, XPERMS_AUDITALLOW))
 405				audited &= ~requested;
 406		}
 407	}
 408
 409	*deniedp = denied;
 410	return audited;
 411}
 412
 413static inline int avc_xperms_audit(struct selinux_state *state,
 414				   u32 ssid, u32 tsid, u16 tclass,
 415				   u32 requested, struct av_decision *avd,
 416				   struct extended_perms_decision *xpd,
 417				   u8 perm, int result,
 418				   struct common_audit_data *ad)
 419{
 420	u32 audited, denied;
 421
 422	audited = avc_xperms_audit_required(
 423			requested, avd, xpd, perm, result, &denied);
 424	if (likely(!audited))
 425		return 0;
 426	return slow_avc_audit(state, ssid, tsid, tclass, requested,
 427			audited, denied, result, ad, 0);
 428}
 429
 430static void avc_node_free(struct rcu_head *rhead)
 431{
 432	struct avc_node *node = container_of(rhead, struct avc_node, rhead);
 433	avc_xperms_free(node->ae.xp_node);
 434	kmem_cache_free(avc_node_cachep, node);
 435	avc_cache_stats_incr(frees);
 436}
 437
 438static void avc_node_delete(struct selinux_avc *avc, struct avc_node *node)
 439{
 440	hlist_del_rcu(&node->list);
 441	call_rcu(&node->rhead, avc_node_free);
 442	atomic_dec(&avc->avc_cache.active_nodes);
 443}
 444
 445static void avc_node_kill(struct selinux_avc *avc, struct avc_node *node)
 446{
 447	avc_xperms_free(node->ae.xp_node);
 448	kmem_cache_free(avc_node_cachep, node);
 449	avc_cache_stats_incr(frees);
 450	atomic_dec(&avc->avc_cache.active_nodes);
 451}
 452
 453static void avc_node_replace(struct selinux_avc *avc,
 454			     struct avc_node *new, struct avc_node *old)
 455{
 456	hlist_replace_rcu(&old->list, &new->list);
 457	call_rcu(&old->rhead, avc_node_free);
 458	atomic_dec(&avc->avc_cache.active_nodes);
 459}
 460
 461static inline int avc_reclaim_node(struct selinux_avc *avc)
 462{
 463	struct avc_node *node;
 464	int hvalue, try, ecx;
 465	unsigned long flags;
 466	struct hlist_head *head;
 467	spinlock_t *lock;
 468
 469	for (try = 0, ecx = 0; try < AVC_CACHE_SLOTS; try++) {
 470		hvalue = atomic_inc_return(&avc->avc_cache.lru_hint) &
 471			(AVC_CACHE_SLOTS - 1);
 472		head = &avc->avc_cache.slots[hvalue];
 473		lock = &avc->avc_cache.slots_lock[hvalue];
 474
 475		if (!spin_trylock_irqsave(lock, flags))
 476			continue;
 477
 478		rcu_read_lock();
 479		hlist_for_each_entry(node, head, list) {
 480			avc_node_delete(avc, node);
 481			avc_cache_stats_incr(reclaims);
 482			ecx++;
 483			if (ecx >= AVC_CACHE_RECLAIM) {
 484				rcu_read_unlock();
 485				spin_unlock_irqrestore(lock, flags);
 486				goto out;
 487			}
 488		}
 489		rcu_read_unlock();
 490		spin_unlock_irqrestore(lock, flags);
 491	}
 492out:
 493	return ecx;
 494}
 495
 496static struct avc_node *avc_alloc_node(struct selinux_avc *avc)
 497{
 498	struct avc_node *node;
 499
 500	node = kmem_cache_zalloc(avc_node_cachep, GFP_NOWAIT);
 501	if (!node)
 502		goto out;
 503
 504	INIT_HLIST_NODE(&node->list);
 505	avc_cache_stats_incr(allocations);
 506
 507	if (atomic_inc_return(&avc->avc_cache.active_nodes) >
 508	    avc->avc_cache_threshold)
 509		avc_reclaim_node(avc);
 510
 511out:
 512	return node;
 513}
 514
 515static void avc_node_populate(struct avc_node *node, u32 ssid, u32 tsid, u16 tclass, struct av_decision *avd)
 516{
 517	node->ae.ssid = ssid;
 518	node->ae.tsid = tsid;
 519	node->ae.tclass = tclass;
 520	memcpy(&node->ae.avd, avd, sizeof(node->ae.avd));
 521}
 522
 523static inline struct avc_node *avc_search_node(struct selinux_avc *avc,
 524					       u32 ssid, u32 tsid, u16 tclass)
 525{
 526	struct avc_node *node, *ret = NULL;
 527	int hvalue;
 528	struct hlist_head *head;
 529
 530	hvalue = avc_hash(ssid, tsid, tclass);
 531	head = &avc->avc_cache.slots[hvalue];
 532	hlist_for_each_entry_rcu(node, head, list) {
 533		if (ssid == node->ae.ssid &&
 534		    tclass == node->ae.tclass &&
 535		    tsid == node->ae.tsid) {
 536			ret = node;
 537			break;
 538		}
 539	}
 540
 541	return ret;
 542}
 543
 544/**
 545 * avc_lookup - Look up an AVC entry.
 546 * @ssid: source security identifier
 547 * @tsid: target security identifier
 548 * @tclass: target security class
 549 *
 550 * Look up an AVC entry that is valid for the
 551 * (@ssid, @tsid), interpreting the permissions
 552 * based on @tclass.  If a valid AVC entry exists,
 553 * then this function returns the avc_node.
 554 * Otherwise, this function returns NULL.
 555 */
 556static struct avc_node *avc_lookup(struct selinux_avc *avc,
 557				   u32 ssid, u32 tsid, u16 tclass)
 558{
 559	struct avc_node *node;
 560
 561	avc_cache_stats_incr(lookups);
 562	node = avc_search_node(avc, ssid, tsid, tclass);
 563
 564	if (node)
 565		return node;
 566
 567	avc_cache_stats_incr(misses);
 568	return NULL;
 569}
 570
 571static int avc_latest_notif_update(struct selinux_avc *avc,
 572				   int seqno, int is_insert)
 573{
 574	int ret = 0;
 575	static DEFINE_SPINLOCK(notif_lock);
 576	unsigned long flag;
 577
 578	spin_lock_irqsave(&notif_lock, flag);
 579	if (is_insert) {
 580		if (seqno < avc->avc_cache.latest_notif) {
 581			pr_warn("SELinux: avc:  seqno %d < latest_notif %d\n",
 582			       seqno, avc->avc_cache.latest_notif);
 583			ret = -EAGAIN;
 584		}
 585	} else {
 586		if (seqno > avc->avc_cache.latest_notif)
 587			avc->avc_cache.latest_notif = seqno;
 588	}
 589	spin_unlock_irqrestore(&notif_lock, flag);
 590
 591	return ret;
 592}
 593
 594/**
 595 * avc_insert - Insert an AVC entry.
 596 * @ssid: source security identifier
 597 * @tsid: target security identifier
 598 * @tclass: target security class
 599 * @avd: resulting av decision
 600 * @xp_node: resulting extended permissions
 601 *
 602 * Insert an AVC entry for the SID pair
 603 * (@ssid, @tsid) and class @tclass.
 604 * The access vectors and the sequence number are
 605 * normally provided by the security server in
 606 * response to a security_compute_av() call.  If the
 607 * sequence number @avd->seqno is not less than the latest
 608 * revocation notification, then the function copies
 609 * the access vectors into a cache entry, returns
 610 * avc_node inserted. Otherwise, this function returns NULL.
 611 */
 612static struct avc_node *avc_insert(struct selinux_avc *avc,
 613				   u32 ssid, u32 tsid, u16 tclass,
 614				   struct av_decision *avd,
 615				   struct avc_xperms_node *xp_node)
 616{
 617	struct avc_node *pos, *node = NULL;
 618	int hvalue;
 619	unsigned long flag;
 
 
 620
 621	if (avc_latest_notif_update(avc, avd->seqno, 1))
 622		goto out;
 623
 624	node = avc_alloc_node(avc);
 625	if (node) {
 626		struct hlist_head *head;
 627		spinlock_t *lock;
 628		int rc = 0;
 629
 630		hvalue = avc_hash(ssid, tsid, tclass);
 631		avc_node_populate(node, ssid, tsid, tclass, avd);
 632		rc = avc_xperms_populate(node, xp_node);
 633		if (rc) {
 634			kmem_cache_free(avc_node_cachep, node);
 635			return NULL;
 636		}
 637		head = &avc->avc_cache.slots[hvalue];
 638		lock = &avc->avc_cache.slots_lock[hvalue];
 639
 640		spin_lock_irqsave(lock, flag);
 641		hlist_for_each_entry(pos, head, list) {
 642			if (pos->ae.ssid == ssid &&
 643			    pos->ae.tsid == tsid &&
 644			    pos->ae.tclass == tclass) {
 645				avc_node_replace(avc, node, pos);
 646				goto found;
 647			}
 
 
 
 
 
 
 
 
 648		}
 649		hlist_add_head_rcu(&node->list, head);
 650found:
 651		spin_unlock_irqrestore(lock, flag);
 652	}
 653out:
 654	return node;
 
 655}
 656
 657/**
 658 * avc_audit_pre_callback - SELinux specific information
 659 * will be called by generic audit code
 660 * @ab: the audit buffer
 661 * @a: audit_data
 662 */
 663static void avc_audit_pre_callback(struct audit_buffer *ab, void *a)
 664{
 665	struct common_audit_data *ad = a;
 666	struct selinux_audit_data *sad = ad->selinux_audit_data;
 667	u32 av = sad->audited;
 668	const char **perms;
 669	int i, perm;
 670
 671	audit_log_format(ab, "avc:  %s ", sad->denied ? "denied" : "granted");
 672
 673	if (av == 0) {
 674		audit_log_format(ab, " null");
 675		return;
 676	}
 677
 678	perms = secclass_map[sad->tclass-1].perms;
 679
 680	audit_log_format(ab, " {");
 681	i = 0;
 682	perm = 1;
 683	while (i < (sizeof(av) * 8)) {
 684		if ((perm & av) && perms[i]) {
 685			audit_log_format(ab, " %s", perms[i]);
 686			av &= ~perm;
 687		}
 688		i++;
 689		perm <<= 1;
 690	}
 691
 692	if (av)
 693		audit_log_format(ab, " 0x%x", av);
 694
 695	audit_log_format(ab, " } for ");
 696}
 697
 698/**
 699 * avc_audit_post_callback - SELinux specific information
 700 * will be called by generic audit code
 701 * @ab: the audit buffer
 702 * @a: audit_data
 703 */
 704static void avc_audit_post_callback(struct audit_buffer *ab, void *a)
 705{
 706	struct common_audit_data *ad = a;
 707	struct selinux_audit_data *sad = ad->selinux_audit_data;
 708	char *scontext;
 
 
 709	u32 scontext_len;
 
 710	int rc;
 711
 712	rc = security_sid_to_context(sad->state, sad->ssid, &scontext,
 713				     &scontext_len);
 714	if (rc)
 715		audit_log_format(ab, " ssid=%d", sad->ssid);
 716	else {
 717		audit_log_format(ab, " scontext=%s", scontext);
 718		kfree(scontext);
 719	}
 720
 721	rc = security_sid_to_context(sad->state, sad->tsid, &scontext,
 722				     &scontext_len);
 723	if (rc)
 724		audit_log_format(ab, " tsid=%d", sad->tsid);
 725	else {
 726		audit_log_format(ab, " tcontext=%s", scontext);
 727		kfree(scontext);
 728	}
 729
 730	audit_log_format(ab, " tclass=%s", secclass_map[sad->tclass-1].name);
 
 731
 732	if (sad->denied)
 733		audit_log_format(ab, " permissive=%u", sad->result ? 0 : 1);
 734
 
 
 
 
 735	/* in case of invalid context report also the actual context string */
 736	rc = security_sid_to_context_inval(sad->state, sad->ssid, &scontext,
 737					   &scontext_len);
 738	if (!rc && scontext) {
 739		if (scontext_len && scontext[scontext_len - 1] == '\0')
 740			scontext_len--;
 741		audit_log_format(ab, " srawcon=");
 742		audit_log_n_untrustedstring(ab, scontext, scontext_len);
 743		kfree(scontext);
 744	}
 745
 746	rc = security_sid_to_context_inval(sad->state, sad->tsid, &scontext,
 747					   &scontext_len);
 748	if (!rc && scontext) {
 749		if (scontext_len && scontext[scontext_len - 1] == '\0')
 750			scontext_len--;
 751		audit_log_format(ab, " trawcon=");
 752		audit_log_n_untrustedstring(ab, scontext, scontext_len);
 753		kfree(scontext);
 754	}
 755}
 756
 757/* This is the slow part of avc audit with big stack footprint */
 758noinline int slow_avc_audit(struct selinux_state *state,
 759			    u32 ssid, u32 tsid, u16 tclass,
 
 
 
 760			    u32 requested, u32 audited, u32 denied, int result,
 761			    struct common_audit_data *a,
 762			    unsigned int flags)
 763{
 764	struct common_audit_data stack_data;
 765	struct selinux_audit_data sad;
 766
 767	if (WARN_ON(!tclass || tclass >= ARRAY_SIZE(secclass_map)))
 768		return -EINVAL;
 769
 770	if (!a) {
 771		a = &stack_data;
 772		a->type = LSM_AUDIT_DATA_NONE;
 773	}
 774
 775	/*
 776	 * When in a RCU walk do the audit on the RCU retry.  This is because
 777	 * the collection of the dname in an inode audit message is not RCU
 778	 * safe.  Note this may drop some audits when the situation changes
 779	 * during retry. However this is logically just as if the operation
 780	 * happened a little later.
 781	 */
 782	if ((a->type == LSM_AUDIT_DATA_INODE) &&
 783	    (flags & MAY_NOT_BLOCK))
 784		return -ECHILD;
 785
 786	sad.tclass = tclass;
 787	sad.requested = requested;
 788	sad.ssid = ssid;
 789	sad.tsid = tsid;
 790	sad.audited = audited;
 791	sad.denied = denied;
 792	sad.result = result;
 793	sad.state = state;
 794
 795	a->selinux_audit_data = &sad;
 796
 797	common_lsm_audit(a, avc_audit_pre_callback, avc_audit_post_callback);
 798	return 0;
 799}
 800
 801/**
 802 * avc_add_callback - Register a callback for security events.
 803 * @callback: callback function
 804 * @events: security events
 805 *
 806 * Register a callback function for events in the set @events.
 807 * Returns %0 on success or -%ENOMEM if insufficient memory
 808 * exists to add the callback.
 809 */
 810int __init avc_add_callback(int (*callback)(u32 event), u32 events)
 811{
 812	struct avc_callback_node *c;
 813	int rc = 0;
 814
 815	c = kmalloc(sizeof(*c), GFP_KERNEL);
 816	if (!c) {
 817		rc = -ENOMEM;
 818		goto out;
 819	}
 820
 821	c->callback = callback;
 822	c->events = events;
 823	c->next = avc_callbacks;
 824	avc_callbacks = c;
 825out:
 826	return rc;
 827}
 828
 829/**
 830 * avc_update_node Update an AVC entry
 831 * @event : Updating event
 832 * @perms : Permission mask bits
 833 * @ssid,@tsid,@tclass : identifier of an AVC entry
 
 
 
 
 
 834 * @seqno : sequence number when decision was made
 835 * @xpd: extended_perms_decision to be added to the node
 836 * @flags: the AVC_* flags, e.g. AVC_NONBLOCKING, AVC_EXTENDED_PERMS, or 0.
 837 *
 838 * if a valid AVC entry doesn't exist,this function returns -ENOENT.
 839 * if kmalloc() called internal returns NULL, this function returns -ENOMEM.
 840 * otherwise, this function updates the AVC entry. The original AVC-entry object
 841 * will release later by RCU.
 842 */
 843static int avc_update_node(struct selinux_avc *avc,
 844			   u32 event, u32 perms, u8 driver, u8 xperm, u32 ssid,
 845			   u32 tsid, u16 tclass, u32 seqno,
 846			   struct extended_perms_decision *xpd,
 847			   u32 flags)
 848{
 849	int hvalue, rc = 0;
 
 850	unsigned long flag;
 851	struct avc_node *pos, *node, *orig = NULL;
 852	struct hlist_head *head;
 853	spinlock_t *lock;
 854
 855	/*
 856	 * If we are in a non-blocking code path, e.g. VFS RCU walk,
 857	 * then we must not add permissions to a cache entry
 858	 * because we cannot safely audit the denial.  Otherwise,
 859	 * during the subsequent blocking retry (e.g. VFS ref walk), we
 860	 * will find the permissions already granted in the cache entry
 861	 * and won't audit anything at all, leading to silent denials in
 862	 * permissive mode that only appear when in enforcing mode.
 863	 *
 864	 * See the corresponding handling in slow_avc_audit(), and the
 865	 * logic in selinux_inode_permission for the MAY_NOT_BLOCK flag,
 866	 * which is transliterated into AVC_NONBLOCKING.
 867	 */
 868	if (flags & AVC_NONBLOCKING)
 869		return 0;
 870
 871	node = avc_alloc_node(avc);
 872	if (!node) {
 873		rc = -ENOMEM;
 874		goto out;
 875	}
 876
 877	/* Lock the target slot */
 878	hvalue = avc_hash(ssid, tsid, tclass);
 879
 880	head = &avc->avc_cache.slots[hvalue];
 881	lock = &avc->avc_cache.slots_lock[hvalue];
 882
 883	spin_lock_irqsave(lock, flag);
 884
 885	hlist_for_each_entry(pos, head, list) {
 886		if (ssid == pos->ae.ssid &&
 887		    tsid == pos->ae.tsid &&
 888		    tclass == pos->ae.tclass &&
 889		    seqno == pos->ae.avd.seqno){
 890			orig = pos;
 891			break;
 892		}
 893	}
 894
 895	if (!orig) {
 896		rc = -ENOENT;
 897		avc_node_kill(avc, node);
 898		goto out_unlock;
 899	}
 900
 901	/*
 902	 * Copy and replace original node.
 903	 */
 904
 905	avc_node_populate(node, ssid, tsid, tclass, &orig->ae.avd);
 906
 907	if (orig->ae.xp_node) {
 908		rc = avc_xperms_populate(node, orig->ae.xp_node);
 909		if (rc) {
 910			kmem_cache_free(avc_node_cachep, node);
 911			goto out_unlock;
 912		}
 913	}
 914
 915	switch (event) {
 916	case AVC_CALLBACK_GRANT:
 917		node->ae.avd.allowed |= perms;
 918		if (node->ae.xp_node && (flags & AVC_EXTENDED_PERMS))
 919			avc_xperms_allow_perm(node->ae.xp_node, driver, xperm);
 920		break;
 921	case AVC_CALLBACK_TRY_REVOKE:
 922	case AVC_CALLBACK_REVOKE:
 923		node->ae.avd.allowed &= ~perms;
 924		break;
 925	case AVC_CALLBACK_AUDITALLOW_ENABLE:
 926		node->ae.avd.auditallow |= perms;
 927		break;
 928	case AVC_CALLBACK_AUDITALLOW_DISABLE:
 929		node->ae.avd.auditallow &= ~perms;
 930		break;
 931	case AVC_CALLBACK_AUDITDENY_ENABLE:
 932		node->ae.avd.auditdeny |= perms;
 933		break;
 934	case AVC_CALLBACK_AUDITDENY_DISABLE:
 935		node->ae.avd.auditdeny &= ~perms;
 936		break;
 937	case AVC_CALLBACK_ADD_XPERMS:
 938		avc_add_xperms_decision(node, xpd);
 
 
 
 
 939		break;
 940	}
 941	avc_node_replace(avc, node, orig);
 942out_unlock:
 943	spin_unlock_irqrestore(lock, flag);
 944out:
 945	return rc;
 946}
 947
 948/**
 949 * avc_flush - Flush the cache
 950 */
 951static void avc_flush(struct selinux_avc *avc)
 952{
 953	struct hlist_head *head;
 954	struct avc_node *node;
 955	spinlock_t *lock;
 956	unsigned long flag;
 957	int i;
 958
 959	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
 960		head = &avc->avc_cache.slots[i];
 961		lock = &avc->avc_cache.slots_lock[i];
 962
 963		spin_lock_irqsave(lock, flag);
 964		/*
 965		 * With preemptable RCU, the outer spinlock does not
 966		 * prevent RCU grace periods from ending.
 967		 */
 968		rcu_read_lock();
 969		hlist_for_each_entry(node, head, list)
 970			avc_node_delete(avc, node);
 971		rcu_read_unlock();
 972		spin_unlock_irqrestore(lock, flag);
 973	}
 974}
 975
 976/**
 977 * avc_ss_reset - Flush the cache and revalidate migrated permissions.
 978 * @seqno: policy sequence number
 979 */
 980int avc_ss_reset(struct selinux_avc *avc, u32 seqno)
 981{
 982	struct avc_callback_node *c;
 983	int rc = 0, tmprc;
 984
 985	avc_flush(avc);
 986
 987	for (c = avc_callbacks; c; c = c->next) {
 988		if (c->events & AVC_CALLBACK_RESET) {
 989			tmprc = c->callback(AVC_CALLBACK_RESET);
 990			/* save the first error encountered for the return
 991			   value and continue processing the callbacks */
 992			if (!rc)
 993				rc = tmprc;
 994		}
 995	}
 996
 997	avc_latest_notif_update(avc, seqno, 0);
 998	return rc;
 999}
1000
1001/*
1002 * Slow-path helper function for avc_has_perm_noaudit,
1003 * when the avc_node lookup fails. We get called with
1004 * the RCU read lock held, and need to return with it
1005 * still held, but drop if for the security compute.
 
 
1006 *
1007 * Don't inline this, since it's the slow-path and just
1008 * results in a bigger stack frame.
 
1009 */
1010static noinline
1011struct avc_node *avc_compute_av(struct selinux_state *state,
1012				u32 ssid, u32 tsid,
1013				u16 tclass, struct av_decision *avd,
1014				struct avc_xperms_node *xp_node)
1015{
1016	rcu_read_unlock();
1017	INIT_LIST_HEAD(&xp_node->xpd_head);
1018	security_compute_av(state, ssid, tsid, tclass, avd, &xp_node->xp);
1019	rcu_read_lock();
1020	return avc_insert(state->avc, ssid, tsid, tclass, avd, xp_node);
1021}
1022
1023static noinline int avc_denied(struct selinux_state *state,
1024			       u32 ssid, u32 tsid,
1025			       u16 tclass, u32 requested,
1026			       u8 driver, u8 xperm, unsigned int flags,
1027			       struct av_decision *avd)
1028{
1029	if (flags & AVC_STRICT)
1030		return -EACCES;
1031
1032	if (enforcing_enabled(state) &&
1033	    !(avd->flags & AVD_FLAGS_PERMISSIVE))
1034		return -EACCES;
1035
1036	avc_update_node(state->avc, AVC_CALLBACK_GRANT, requested, driver,
1037			xperm, ssid, tsid, tclass, avd->seqno, NULL, flags);
1038	return 0;
1039}
1040
1041/*
1042 * The avc extended permissions logic adds an additional 256 bits of
1043 * permissions to an avc node when extended permissions for that node are
1044 * specified in the avtab. If the additional 256 permissions is not adequate,
1045 * as-is the case with ioctls, then multiple may be chained together and the
1046 * driver field is used to specify which set contains the permission.
1047 */
1048int avc_has_extended_perms(struct selinux_state *state,
1049			   u32 ssid, u32 tsid, u16 tclass, u32 requested,
1050			   u8 driver, u8 xperm, struct common_audit_data *ad)
1051{
1052	struct avc_node *node;
1053	struct av_decision avd;
1054	u32 denied;
1055	struct extended_perms_decision local_xpd;
1056	struct extended_perms_decision *xpd = NULL;
1057	struct extended_perms_data allowed;
1058	struct extended_perms_data auditallow;
1059	struct extended_perms_data dontaudit;
1060	struct avc_xperms_node local_xp_node;
1061	struct avc_xperms_node *xp_node;
1062	int rc = 0, rc2;
1063
1064	xp_node = &local_xp_node;
1065	if (WARN_ON(!requested))
1066		return -EACCES;
1067
1068	rcu_read_lock();
1069
1070	node = avc_lookup(state->avc, ssid, tsid, tclass);
1071	if (unlikely(!node)) {
1072		node = avc_compute_av(state, ssid, tsid, tclass, &avd, xp_node);
1073	} else {
1074		memcpy(&avd, &node->ae.avd, sizeof(avd));
1075		xp_node = node->ae.xp_node;
1076	}
1077	/* if extended permissions are not defined, only consider av_decision */
1078	if (!xp_node || !xp_node->xp.len)
1079		goto decision;
1080
1081	local_xpd.allowed = &allowed;
1082	local_xpd.auditallow = &auditallow;
1083	local_xpd.dontaudit = &dontaudit;
1084
1085	xpd = avc_xperms_decision_lookup(driver, xp_node);
1086	if (unlikely(!xpd)) {
1087		/*
1088		 * Compute the extended_perms_decision only if the driver
1089		 * is flagged
1090		 */
1091		if (!security_xperm_test(xp_node->xp.drivers.p, driver)) {
 
1092			avd.allowed &= ~requested;
1093			goto decision;
1094		}
1095		rcu_read_unlock();
1096		security_compute_xperms_decision(state, ssid, tsid, tclass,
1097						 driver, &local_xpd);
1098		rcu_read_lock();
1099		avc_update_node(state->avc, AVC_CALLBACK_ADD_XPERMS, requested,
1100				driver, xperm, ssid, tsid, tclass, avd.seqno,
1101				&local_xpd, 0);
1102	} else {
1103		avc_quick_copy_xperms_decision(xperm, &local_xpd, xpd);
1104	}
1105	xpd = &local_xpd;
1106
1107	if (!avc_xperms_has_perm(xpd, xperm, XPERMS_ALLOWED))
1108		avd.allowed &= ~requested;
1109
1110decision:
1111	denied = requested & ~(avd.allowed);
1112	if (unlikely(denied))
1113		rc = avc_denied(state, ssid, tsid, tclass, requested,
1114				driver, xperm, AVC_EXTENDED_PERMS, &avd);
1115
1116	rcu_read_unlock();
1117
1118	rc2 = avc_xperms_audit(state, ssid, tsid, tclass, requested,
1119			&avd, xpd, xperm, rc, ad);
1120	if (rc2)
1121		return rc2;
1122	return rc;
1123}
1124
1125/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1126 * avc_has_perm_noaudit - Check permissions but perform no auditing.
1127 * @ssid: source security identifier
1128 * @tsid: target security identifier
1129 * @tclass: target security class
1130 * @requested: requested permissions, interpreted based on @tclass
1131 * @flags:  AVC_STRICT, AVC_NONBLOCKING, or 0
1132 * @avd: access vector decisions
1133 *
1134 * Check the AVC to determine whether the @requested permissions are granted
1135 * for the SID pair (@ssid, @tsid), interpreting the permissions
1136 * based on @tclass, and call the security server on a cache miss to obtain
1137 * a new decision and add it to the cache.  Return a copy of the decisions
1138 * in @avd.  Return %0 if all @requested permissions are granted,
1139 * -%EACCES if any permissions are denied, or another -errno upon
1140 * other errors.  This function is typically called by avc_has_perm(),
1141 * but may also be called directly to separate permission checking from
1142 * auditing, e.g. in cases where a lock must be held for the check but
1143 * should be released for the auditing.
1144 */
1145inline int avc_has_perm_noaudit(struct selinux_state *state,
1146				u32 ssid, u32 tsid,
1147				u16 tclass, u32 requested,
1148				unsigned int flags,
1149				struct av_decision *avd)
1150{
1151	struct avc_node *node;
1152	struct avc_xperms_node xp_node;
1153	int rc = 0;
1154	u32 denied;
 
1155
1156	if (WARN_ON(!requested))
1157		return -EACCES;
1158
1159	rcu_read_lock();
 
 
 
 
 
 
 
 
 
1160
1161	node = avc_lookup(state->avc, ssid, tsid, tclass);
1162	if (unlikely(!node))
1163		node = avc_compute_av(state, ssid, tsid, tclass, avd, &xp_node);
1164	else
1165		memcpy(avd, &node->ae.avd, sizeof(*avd));
1166
1167	denied = requested & ~(avd->allowed);
1168	if (unlikely(denied))
1169		rc = avc_denied(state, ssid, tsid, tclass, requested, 0, 0,
1170				flags, avd);
1171
1172	rcu_read_unlock();
1173	return rc;
1174}
1175
1176/**
1177 * avc_has_perm - Check permissions and perform any appropriate auditing.
1178 * @ssid: source security identifier
1179 * @tsid: target security identifier
1180 * @tclass: target security class
1181 * @requested: requested permissions, interpreted based on @tclass
1182 * @auditdata: auxiliary audit data
1183 *
1184 * Check the AVC to determine whether the @requested permissions are granted
1185 * for the SID pair (@ssid, @tsid), interpreting the permissions
1186 * based on @tclass, and call the security server on a cache miss to obtain
1187 * a new decision and add it to the cache.  Audit the granting or denial of
1188 * permissions in accordance with the policy.  Return %0 if all @requested
1189 * permissions are granted, -%EACCES if any permissions are denied, or
1190 * another -errno upon other errors.
1191 */
1192int avc_has_perm(struct selinux_state *state, u32 ssid, u32 tsid, u16 tclass,
1193		 u32 requested, struct common_audit_data *auditdata)
1194{
1195	struct av_decision avd;
1196	int rc, rc2;
1197
1198	rc = avc_has_perm_noaudit(state, ssid, tsid, tclass, requested, 0,
1199				  &avd);
1200
1201	rc2 = avc_audit(state, ssid, tsid, tclass, requested, &avd, rc,
1202			auditdata, 0);
1203	if (rc2)
1204		return rc2;
1205	return rc;
1206}
1207
1208u32 avc_policy_seqno(struct selinux_state *state)
1209{
1210	return state->avc->avc_cache.latest_notif;
1211}
1212
1213void avc_disable(void)
1214{
1215	/*
1216	 * If you are looking at this because you have realized that we are
1217	 * not destroying the avc_node_cachep it might be easy to fix, but
1218	 * I don't know the memory barrier semantics well enough to know.  It's
1219	 * possible that some other task dereferenced security_ops when
1220	 * it still pointed to selinux operations.  If that is the case it's
1221	 * possible that it is about to use the avc and is about to need the
1222	 * avc_node_cachep.  I know I could wrap the security.c security_ops call
1223	 * in an rcu_lock, but seriously, it's not worth it.  Instead I just flush
1224	 * the cache and get that memory back.
1225	 */
1226	if (avc_node_cachep) {
1227		avc_flush(selinux_state.avc);
1228		/* kmem_cache_destroy(avc_node_cachep); */
1229	}
1230}
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Implementation of the kernel access vector cache (AVC).
   4 *
   5 * Authors:  Stephen Smalley, <stephen.smalley.work@gmail.com>
   6 *	     James Morris <jmorris@redhat.com>
   7 *
   8 * Update:   KaiGai, Kohei <kaigai@ak.jp.nec.com>
   9 *	Replaced the avc_lock spinlock by RCU.
  10 *
  11 * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
  12 */
  13#include <linux/types.h>
  14#include <linux/stddef.h>
  15#include <linux/kernel.h>
  16#include <linux/slab.h>
  17#include <linux/fs.h>
  18#include <linux/dcache.h>
  19#include <linux/init.h>
  20#include <linux/skbuff.h>
  21#include <linux/percpu.h>
  22#include <linux/list.h>
  23#include <net/sock.h>
  24#include <linux/un.h>
  25#include <net/af_unix.h>
  26#include <linux/ip.h>
  27#include <linux/audit.h>
  28#include <linux/ipv6.h>
  29#include <net/ipv6.h>
  30#include "avc.h"
  31#include "avc_ss.h"
  32#include "classmap.h"
  33
  34#define CREATE_TRACE_POINTS
  35#include <trace/events/avc.h>
  36
  37#define AVC_CACHE_SLOTS			512
  38#define AVC_DEF_CACHE_THRESHOLD		512
  39#define AVC_CACHE_RECLAIM		16
  40
  41#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
  42#define avc_cache_stats_incr(field)	this_cpu_inc(avc_cache_stats.field)
  43#else
  44#define avc_cache_stats_incr(field)	do {} while (0)
  45#endif
  46
  47struct avc_entry {
  48	u32			ssid;
  49	u32			tsid;
  50	u16			tclass;
  51	struct av_decision	avd;
  52	struct avc_xperms_node	*xp_node;
  53};
  54
  55struct avc_node {
  56	struct avc_entry	ae;
  57	struct hlist_node	list; /* anchored in avc_cache->slots[i] */
  58	struct rcu_head		rhead;
  59};
  60
  61struct avc_xperms_decision_node {
  62	struct extended_perms_decision xpd;
  63	struct list_head xpd_list; /* list of extended_perms_decision */
  64};
  65
  66struct avc_xperms_node {
  67	struct extended_perms xp;
  68	struct list_head xpd_head; /* list head of extended_perms_decision */
  69};
  70
  71struct avc_cache {
  72	struct hlist_head	slots[AVC_CACHE_SLOTS]; /* head for avc_node->list */
  73	spinlock_t		slots_lock[AVC_CACHE_SLOTS]; /* lock for writes */
  74	atomic_t		lru_hint;	/* LRU hint for reclaim scan */
  75	atomic_t		active_nodes;
  76	u32			latest_notif;	/* latest revocation notification */
  77};
  78
  79struct avc_callback_node {
  80	int (*callback) (u32 event);
  81	u32 events;
  82	struct avc_callback_node *next;
  83};
  84
  85#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
  86DEFINE_PER_CPU(struct avc_cache_stats, avc_cache_stats) = { 0 };
  87#endif
  88
  89struct selinux_avc {
  90	unsigned int avc_cache_threshold;
  91	struct avc_cache avc_cache;
  92};
  93
  94static struct selinux_avc selinux_avc;
  95
  96void selinux_avc_init(void)
  97{
  98	int i;
  99
 100	selinux_avc.avc_cache_threshold = AVC_DEF_CACHE_THRESHOLD;
 101	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
 102		INIT_HLIST_HEAD(&selinux_avc.avc_cache.slots[i]);
 103		spin_lock_init(&selinux_avc.avc_cache.slots_lock[i]);
 104	}
 105	atomic_set(&selinux_avc.avc_cache.active_nodes, 0);
 106	atomic_set(&selinux_avc.avc_cache.lru_hint, 0);
 
 107}
 108
 109unsigned int avc_get_cache_threshold(void)
 110{
 111	return selinux_avc.avc_cache_threshold;
 112}
 113
 114void avc_set_cache_threshold(unsigned int cache_threshold)
 
 115{
 116	selinux_avc.avc_cache_threshold = cache_threshold;
 117}
 118
 119static struct avc_callback_node *avc_callbacks __ro_after_init;
 120static struct kmem_cache *avc_node_cachep __ro_after_init;
 121static struct kmem_cache *avc_xperms_data_cachep __ro_after_init;
 122static struct kmem_cache *avc_xperms_decision_cachep __ro_after_init;
 123static struct kmem_cache *avc_xperms_cachep __ro_after_init;
 124
 125static inline u32 avc_hash(u32 ssid, u32 tsid, u16 tclass)
 126{
 127	return (ssid ^ (tsid<<2) ^ (tclass<<4)) & (AVC_CACHE_SLOTS - 1);
 128}
 129
 130/**
 131 * avc_init - Initialize the AVC.
 132 *
 133 * Initialize the access vector cache.
 134 */
 135void __init avc_init(void)
 136{
 137	avc_node_cachep = KMEM_CACHE(avc_node, SLAB_PANIC);
 138	avc_xperms_cachep = KMEM_CACHE(avc_xperms_node, SLAB_PANIC);
 139	avc_xperms_decision_cachep = KMEM_CACHE(avc_xperms_decision_node, SLAB_PANIC);
 140	avc_xperms_data_cachep = KMEM_CACHE(extended_perms_data, SLAB_PANIC);
 
 
 
 
 
 
 
 
 141}
 142
 143int avc_get_hash_stats(char *page)
 144{
 145	int i, chain_len, max_chain_len, slots_used;
 146	struct avc_node *node;
 147	struct hlist_head *head;
 148
 149	rcu_read_lock();
 150
 151	slots_used = 0;
 152	max_chain_len = 0;
 153	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
 154		head = &selinux_avc.avc_cache.slots[i];
 155		if (!hlist_empty(head)) {
 156			slots_used++;
 157			chain_len = 0;
 158			hlist_for_each_entry_rcu(node, head, list)
 159				chain_len++;
 160			if (chain_len > max_chain_len)
 161				max_chain_len = chain_len;
 162		}
 163	}
 164
 165	rcu_read_unlock();
 166
 167	return scnprintf(page, PAGE_SIZE, "entries: %d\nbuckets used: %d/%d\n"
 168			 "longest chain: %d\n",
 169			 atomic_read(&selinux_avc.avc_cache.active_nodes),
 170			 slots_used, AVC_CACHE_SLOTS, max_chain_len);
 171}
 172
 173/*
 174 * using a linked list for extended_perms_decision lookup because the list is
 175 * always small. i.e. less than 5, typically 1
 176 */
 177static struct extended_perms_decision *
 178avc_xperms_decision_lookup(u8 driver, u8 base_perm,
 179			   struct avc_xperms_node *xp_node)
 180{
 181	struct avc_xperms_decision_node *xpd_node;
 182
 183	list_for_each_entry(xpd_node, &xp_node->xpd_head, xpd_list) {
 184		if (xpd_node->xpd.driver == driver &&
 185		    xpd_node->xpd.base_perm == base_perm)
 186			return &xpd_node->xpd;
 187	}
 188	return NULL;
 189}
 190
 191static inline unsigned int
 192avc_xperms_has_perm(struct extended_perms_decision *xpd,
 193					u8 perm, u8 which)
 194{
 195	unsigned int rc = 0;
 196
 197	if ((which == XPERMS_ALLOWED) &&
 198			(xpd->used & XPERMS_ALLOWED))
 199		rc = security_xperm_test(xpd->allowed->p, perm);
 200	else if ((which == XPERMS_AUDITALLOW) &&
 201			(xpd->used & XPERMS_AUDITALLOW))
 202		rc = security_xperm_test(xpd->auditallow->p, perm);
 203	else if ((which == XPERMS_DONTAUDIT) &&
 204			(xpd->used & XPERMS_DONTAUDIT))
 205		rc = security_xperm_test(xpd->dontaudit->p, perm);
 206	return rc;
 207}
 208
 209static void avc_xperms_allow_perm(struct avc_xperms_node *xp_node,
 210				  u8 driver, u8 base_perm, u8 perm)
 211{
 212	struct extended_perms_decision *xpd;
 213	security_xperm_set(xp_node->xp.drivers.p, driver);
 214	xp_node->xp.base_perms |= base_perm;
 215	xpd = avc_xperms_decision_lookup(driver, base_perm, xp_node);
 216	if (xpd && xpd->allowed)
 217		security_xperm_set(xpd->allowed->p, perm);
 218}
 219
 220static void avc_xperms_decision_free(struct avc_xperms_decision_node *xpd_node)
 221{
 222	struct extended_perms_decision *xpd;
 223
 224	xpd = &xpd_node->xpd;
 225	if (xpd->allowed)
 226		kmem_cache_free(avc_xperms_data_cachep, xpd->allowed);
 227	if (xpd->auditallow)
 228		kmem_cache_free(avc_xperms_data_cachep, xpd->auditallow);
 229	if (xpd->dontaudit)
 230		kmem_cache_free(avc_xperms_data_cachep, xpd->dontaudit);
 231	kmem_cache_free(avc_xperms_decision_cachep, xpd_node);
 232}
 233
 234static void avc_xperms_free(struct avc_xperms_node *xp_node)
 235{
 236	struct avc_xperms_decision_node *xpd_node, *tmp;
 237
 238	if (!xp_node)
 239		return;
 240
 241	list_for_each_entry_safe(xpd_node, tmp, &xp_node->xpd_head, xpd_list) {
 242		list_del(&xpd_node->xpd_list);
 243		avc_xperms_decision_free(xpd_node);
 244	}
 245	kmem_cache_free(avc_xperms_cachep, xp_node);
 246}
 247
 248static void avc_copy_xperms_decision(struct extended_perms_decision *dest,
 249					struct extended_perms_decision *src)
 250{
 251	dest->base_perm = src->base_perm;
 252	dest->driver = src->driver;
 253	dest->used = src->used;
 254	if (dest->used & XPERMS_ALLOWED)
 255		memcpy(dest->allowed->p, src->allowed->p,
 256				sizeof(src->allowed->p));
 257	if (dest->used & XPERMS_AUDITALLOW)
 258		memcpy(dest->auditallow->p, src->auditallow->p,
 259				sizeof(src->auditallow->p));
 260	if (dest->used & XPERMS_DONTAUDIT)
 261		memcpy(dest->dontaudit->p, src->dontaudit->p,
 262				sizeof(src->dontaudit->p));
 263}
 264
 265/*
 266 * similar to avc_copy_xperms_decision, but only copy decision
 267 * information relevant to this perm
 268 */
 269static inline void avc_quick_copy_xperms_decision(u8 perm,
 270			struct extended_perms_decision *dest,
 271			struct extended_perms_decision *src)
 272{
 273	/*
 274	 * compute index of the u32 of the 256 bits (8 u32s) that contain this
 275	 * command permission
 276	 */
 277	u8 i = perm >> 5;
 278
 279	dest->base_perm = src->base_perm;
 280	dest->used = src->used;
 281	if (dest->used & XPERMS_ALLOWED)
 282		dest->allowed->p[i] = src->allowed->p[i];
 283	if (dest->used & XPERMS_AUDITALLOW)
 284		dest->auditallow->p[i] = src->auditallow->p[i];
 285	if (dest->used & XPERMS_DONTAUDIT)
 286		dest->dontaudit->p[i] = src->dontaudit->p[i];
 287}
 288
 289static struct avc_xperms_decision_node
 290		*avc_xperms_decision_alloc(u8 which)
 291{
 292	struct avc_xperms_decision_node *xpd_node;
 293	struct extended_perms_decision *xpd;
 294
 295	xpd_node = kmem_cache_zalloc(avc_xperms_decision_cachep,
 296				     GFP_NOWAIT | __GFP_NOWARN);
 297	if (!xpd_node)
 298		return NULL;
 299
 300	xpd = &xpd_node->xpd;
 301	if (which & XPERMS_ALLOWED) {
 302		xpd->allowed = kmem_cache_zalloc(avc_xperms_data_cachep,
 303						GFP_NOWAIT | __GFP_NOWARN);
 304		if (!xpd->allowed)
 305			goto error;
 306	}
 307	if (which & XPERMS_AUDITALLOW) {
 308		xpd->auditallow = kmem_cache_zalloc(avc_xperms_data_cachep,
 309						GFP_NOWAIT | __GFP_NOWARN);
 310		if (!xpd->auditallow)
 311			goto error;
 312	}
 313	if (which & XPERMS_DONTAUDIT) {
 314		xpd->dontaudit = kmem_cache_zalloc(avc_xperms_data_cachep,
 315						GFP_NOWAIT | __GFP_NOWARN);
 316		if (!xpd->dontaudit)
 317			goto error;
 318	}
 319	return xpd_node;
 320error:
 321	avc_xperms_decision_free(xpd_node);
 322	return NULL;
 323}
 324
 325static int avc_add_xperms_decision(struct avc_node *node,
 326			struct extended_perms_decision *src)
 327{
 328	struct avc_xperms_decision_node *dest_xpd;
 329
 
 330	dest_xpd = avc_xperms_decision_alloc(src->used);
 331	if (!dest_xpd)
 332		return -ENOMEM;
 333	avc_copy_xperms_decision(&dest_xpd->xpd, src);
 334	list_add(&dest_xpd->xpd_list, &node->ae.xp_node->xpd_head);
 335	node->ae.xp_node->xp.len++;
 336	return 0;
 337}
 338
 339static struct avc_xperms_node *avc_xperms_alloc(void)
 340{
 341	struct avc_xperms_node *xp_node;
 342
 343	xp_node = kmem_cache_zalloc(avc_xperms_cachep, GFP_NOWAIT | __GFP_NOWARN);
 344	if (!xp_node)
 345		return xp_node;
 346	INIT_LIST_HEAD(&xp_node->xpd_head);
 347	return xp_node;
 348}
 349
 350static int avc_xperms_populate(struct avc_node *node,
 351				struct avc_xperms_node *src)
 352{
 353	struct avc_xperms_node *dest;
 354	struct avc_xperms_decision_node *dest_xpd;
 355	struct avc_xperms_decision_node *src_xpd;
 356
 357	if (src->xp.len == 0)
 358		return 0;
 359	dest = avc_xperms_alloc();
 360	if (!dest)
 361		return -ENOMEM;
 362
 363	memcpy(dest->xp.drivers.p, src->xp.drivers.p, sizeof(dest->xp.drivers.p));
 364	dest->xp.len = src->xp.len;
 365	dest->xp.base_perms = src->xp.base_perms;
 366
 367	/* for each source xpd allocate a destination xpd and copy */
 368	list_for_each_entry(src_xpd, &src->xpd_head, xpd_list) {
 369		dest_xpd = avc_xperms_decision_alloc(src_xpd->xpd.used);
 370		if (!dest_xpd)
 371			goto error;
 372		avc_copy_xperms_decision(&dest_xpd->xpd, &src_xpd->xpd);
 373		list_add(&dest_xpd->xpd_list, &dest->xpd_head);
 374	}
 375	node->ae.xp_node = dest;
 376	return 0;
 377error:
 378	avc_xperms_free(dest);
 379	return -ENOMEM;
 380
 381}
 382
 383static inline u32 avc_xperms_audit_required(u32 requested,
 384					struct av_decision *avd,
 385					struct extended_perms_decision *xpd,
 386					u8 perm,
 387					int result,
 388					u32 *deniedp)
 389{
 390	u32 denied, audited;
 391
 392	denied = requested & ~avd->allowed;
 393	if (unlikely(denied)) {
 394		audited = denied & avd->auditdeny;
 395		if (audited && xpd) {
 396			if (avc_xperms_has_perm(xpd, perm, XPERMS_DONTAUDIT))
 397				audited = 0;
 398		}
 399	} else if (result) {
 400		audited = denied = requested;
 401	} else {
 402		audited = requested & avd->auditallow;
 403		if (audited && xpd) {
 404			if (!avc_xperms_has_perm(xpd, perm, XPERMS_AUDITALLOW))
 405				audited = 0;
 406		}
 407	}
 408
 409	*deniedp = denied;
 410	return audited;
 411}
 412
 413static inline int avc_xperms_audit(u32 ssid, u32 tsid, u16 tclass,
 
 414				   u32 requested, struct av_decision *avd,
 415				   struct extended_perms_decision *xpd,
 416				   u8 perm, int result,
 417				   struct common_audit_data *ad)
 418{
 419	u32 audited, denied;
 420
 421	audited = avc_xperms_audit_required(
 422			requested, avd, xpd, perm, result, &denied);
 423	if (likely(!audited))
 424		return 0;
 425	return slow_avc_audit(ssid, tsid, tclass, requested,
 426			audited, denied, result, ad);
 427}
 428
 429static void avc_node_free(struct rcu_head *rhead)
 430{
 431	struct avc_node *node = container_of(rhead, struct avc_node, rhead);
 432	avc_xperms_free(node->ae.xp_node);
 433	kmem_cache_free(avc_node_cachep, node);
 434	avc_cache_stats_incr(frees);
 435}
 436
 437static void avc_node_delete(struct avc_node *node)
 438{
 439	hlist_del_rcu(&node->list);
 440	call_rcu(&node->rhead, avc_node_free);
 441	atomic_dec(&selinux_avc.avc_cache.active_nodes);
 442}
 443
 444static void avc_node_kill(struct avc_node *node)
 445{
 446	avc_xperms_free(node->ae.xp_node);
 447	kmem_cache_free(avc_node_cachep, node);
 448	avc_cache_stats_incr(frees);
 449	atomic_dec(&selinux_avc.avc_cache.active_nodes);
 450}
 451
 452static void avc_node_replace(struct avc_node *new, struct avc_node *old)
 
 453{
 454	hlist_replace_rcu(&old->list, &new->list);
 455	call_rcu(&old->rhead, avc_node_free);
 456	atomic_dec(&selinux_avc.avc_cache.active_nodes);
 457}
 458
 459static inline int avc_reclaim_node(void)
 460{
 461	struct avc_node *node;
 462	int hvalue, try, ecx;
 463	unsigned long flags;
 464	struct hlist_head *head;
 465	spinlock_t *lock;
 466
 467	for (try = 0, ecx = 0; try < AVC_CACHE_SLOTS; try++) {
 468		hvalue = atomic_inc_return(&selinux_avc.avc_cache.lru_hint) &
 469			(AVC_CACHE_SLOTS - 1);
 470		head = &selinux_avc.avc_cache.slots[hvalue];
 471		lock = &selinux_avc.avc_cache.slots_lock[hvalue];
 472
 473		if (!spin_trylock_irqsave(lock, flags))
 474			continue;
 475
 476		rcu_read_lock();
 477		hlist_for_each_entry(node, head, list) {
 478			avc_node_delete(node);
 479			avc_cache_stats_incr(reclaims);
 480			ecx++;
 481			if (ecx >= AVC_CACHE_RECLAIM) {
 482				rcu_read_unlock();
 483				spin_unlock_irqrestore(lock, flags);
 484				goto out;
 485			}
 486		}
 487		rcu_read_unlock();
 488		spin_unlock_irqrestore(lock, flags);
 489	}
 490out:
 491	return ecx;
 492}
 493
 494static struct avc_node *avc_alloc_node(void)
 495{
 496	struct avc_node *node;
 497
 498	node = kmem_cache_zalloc(avc_node_cachep, GFP_NOWAIT | __GFP_NOWARN);
 499	if (!node)
 500		goto out;
 501
 502	INIT_HLIST_NODE(&node->list);
 503	avc_cache_stats_incr(allocations);
 504
 505	if (atomic_inc_return(&selinux_avc.avc_cache.active_nodes) >
 506	    selinux_avc.avc_cache_threshold)
 507		avc_reclaim_node();
 508
 509out:
 510	return node;
 511}
 512
 513static void avc_node_populate(struct avc_node *node, u32 ssid, u32 tsid, u16 tclass, struct av_decision *avd)
 514{
 515	node->ae.ssid = ssid;
 516	node->ae.tsid = tsid;
 517	node->ae.tclass = tclass;
 518	memcpy(&node->ae.avd, avd, sizeof(node->ae.avd));
 519}
 520
 521static inline struct avc_node *avc_search_node(u32 ssid, u32 tsid, u16 tclass)
 
 522{
 523	struct avc_node *node, *ret = NULL;
 524	u32 hvalue;
 525	struct hlist_head *head;
 526
 527	hvalue = avc_hash(ssid, tsid, tclass);
 528	head = &selinux_avc.avc_cache.slots[hvalue];
 529	hlist_for_each_entry_rcu(node, head, list) {
 530		if (ssid == node->ae.ssid &&
 531		    tclass == node->ae.tclass &&
 532		    tsid == node->ae.tsid) {
 533			ret = node;
 534			break;
 535		}
 536	}
 537
 538	return ret;
 539}
 540
 541/**
 542 * avc_lookup - Look up an AVC entry.
 543 * @ssid: source security identifier
 544 * @tsid: target security identifier
 545 * @tclass: target security class
 546 *
 547 * Look up an AVC entry that is valid for the
 548 * (@ssid, @tsid), interpreting the permissions
 549 * based on @tclass.  If a valid AVC entry exists,
 550 * then this function returns the avc_node.
 551 * Otherwise, this function returns NULL.
 552 */
 553static struct avc_node *avc_lookup(u32 ssid, u32 tsid, u16 tclass)
 
 554{
 555	struct avc_node *node;
 556
 557	avc_cache_stats_incr(lookups);
 558	node = avc_search_node(ssid, tsid, tclass);
 559
 560	if (node)
 561		return node;
 562
 563	avc_cache_stats_incr(misses);
 564	return NULL;
 565}
 566
 567static int avc_latest_notif_update(u32 seqno, int is_insert)
 
 568{
 569	int ret = 0;
 570	static DEFINE_SPINLOCK(notif_lock);
 571	unsigned long flag;
 572
 573	spin_lock_irqsave(&notif_lock, flag);
 574	if (is_insert) {
 575		if (seqno < selinux_avc.avc_cache.latest_notif) {
 576			pr_warn("SELinux: avc:  seqno %d < latest_notif %d\n",
 577			       seqno, selinux_avc.avc_cache.latest_notif);
 578			ret = -EAGAIN;
 579		}
 580	} else {
 581		if (seqno > selinux_avc.avc_cache.latest_notif)
 582			selinux_avc.avc_cache.latest_notif = seqno;
 583	}
 584	spin_unlock_irqrestore(&notif_lock, flag);
 585
 586	return ret;
 587}
 588
 589/**
 590 * avc_insert - Insert an AVC entry.
 591 * @ssid: source security identifier
 592 * @tsid: target security identifier
 593 * @tclass: target security class
 594 * @avd: resulting av decision
 595 * @xp_node: resulting extended permissions
 596 *
 597 * Insert an AVC entry for the SID pair
 598 * (@ssid, @tsid) and class @tclass.
 599 * The access vectors and the sequence number are
 600 * normally provided by the security server in
 601 * response to a security_compute_av() call.  If the
 602 * sequence number @avd->seqno is not less than the latest
 603 * revocation notification, then the function copies
 604 * the access vectors into a cache entry.
 
 605 */
 606static void avc_insert(u32 ssid, u32 tsid, u16 tclass,
 607		       struct av_decision *avd, struct avc_xperms_node *xp_node)
 
 
 608{
 609	struct avc_node *pos, *node = NULL;
 610	u32 hvalue;
 611	unsigned long flag;
 612	spinlock_t *lock;
 613	struct hlist_head *head;
 614
 615	if (avc_latest_notif_update(avd->seqno, 1))
 616		return;
 617
 618	node = avc_alloc_node();
 619	if (!node)
 620		return;
 
 
 
 
 
 
 
 
 
 
 
 
 621
 622	avc_node_populate(node, ssid, tsid, tclass, avd);
 623	if (avc_xperms_populate(node, xp_node)) {
 624		avc_node_kill(node);
 625		return;
 626	}
 627
 628	hvalue = avc_hash(ssid, tsid, tclass);
 629	head = &selinux_avc.avc_cache.slots[hvalue];
 630	lock = &selinux_avc.avc_cache.slots_lock[hvalue];
 631	spin_lock_irqsave(lock, flag);
 632	hlist_for_each_entry(pos, head, list) {
 633		if (pos->ae.ssid == ssid &&
 634			pos->ae.tsid == tsid &&
 635			pos->ae.tclass == tclass) {
 636			avc_node_replace(node, pos);
 637			goto found;
 638		}
 
 
 
 639	}
 640	hlist_add_head_rcu(&node->list, head);
 641found:
 642	spin_unlock_irqrestore(lock, flag);
 643}
 644
 645/**
 646 * avc_audit_pre_callback - SELinux specific information
 647 * will be called by generic audit code
 648 * @ab: the audit buffer
 649 * @a: audit_data
 650 */
 651static void avc_audit_pre_callback(struct audit_buffer *ab, void *a)
 652{
 653	struct common_audit_data *ad = a;
 654	struct selinux_audit_data *sad = ad->selinux_audit_data;
 655	u32 av = sad->audited, perm;
 656	const char *const *perms;
 657	u32 i;
 658
 659	audit_log_format(ab, "avc:  %s ", sad->denied ? "denied" : "granted");
 660
 661	if (av == 0) {
 662		audit_log_format(ab, " null");
 663		return;
 664	}
 665
 666	perms = secclass_map[sad->tclass-1].perms;
 667
 668	audit_log_format(ab, " {");
 669	i = 0;
 670	perm = 1;
 671	while (i < (sizeof(av) * 8)) {
 672		if ((perm & av) && perms[i]) {
 673			audit_log_format(ab, " %s", perms[i]);
 674			av &= ~perm;
 675		}
 676		i++;
 677		perm <<= 1;
 678	}
 679
 680	if (av)
 681		audit_log_format(ab, " 0x%x", av);
 682
 683	audit_log_format(ab, " } for ");
 684}
 685
 686/**
 687 * avc_audit_post_callback - SELinux specific information
 688 * will be called by generic audit code
 689 * @ab: the audit buffer
 690 * @a: audit_data
 691 */
 692static void avc_audit_post_callback(struct audit_buffer *ab, void *a)
 693{
 694	struct common_audit_data *ad = a;
 695	struct selinux_audit_data *sad = ad->selinux_audit_data;
 696	char *scontext = NULL;
 697	char *tcontext = NULL;
 698	const char *tclass = NULL;
 699	u32 scontext_len;
 700	u32 tcontext_len;
 701	int rc;
 702
 703	rc = security_sid_to_context(sad->ssid, &scontext,
 704				     &scontext_len);
 705	if (rc)
 706		audit_log_format(ab, " ssid=%d", sad->ssid);
 707	else
 708		audit_log_format(ab, " scontext=%s", scontext);
 
 
 709
 710	rc = security_sid_to_context(sad->tsid, &tcontext,
 711				     &tcontext_len);
 712	if (rc)
 713		audit_log_format(ab, " tsid=%d", sad->tsid);
 714	else
 715		audit_log_format(ab, " tcontext=%s", tcontext);
 
 
 716
 717	tclass = secclass_map[sad->tclass-1].name;
 718	audit_log_format(ab, " tclass=%s", tclass);
 719
 720	if (sad->denied)
 721		audit_log_format(ab, " permissive=%u", sad->result ? 0 : 1);
 722
 723	trace_selinux_audited(sad, scontext, tcontext, tclass);
 724	kfree(tcontext);
 725	kfree(scontext);
 726
 727	/* in case of invalid context report also the actual context string */
 728	rc = security_sid_to_context_inval(sad->ssid, &scontext,
 729					   &scontext_len);
 730	if (!rc && scontext) {
 731		if (scontext_len && scontext[scontext_len - 1] == '\0')
 732			scontext_len--;
 733		audit_log_format(ab, " srawcon=");
 734		audit_log_n_untrustedstring(ab, scontext, scontext_len);
 735		kfree(scontext);
 736	}
 737
 738	rc = security_sid_to_context_inval(sad->tsid, &scontext,
 739					   &scontext_len);
 740	if (!rc && scontext) {
 741		if (scontext_len && scontext[scontext_len - 1] == '\0')
 742			scontext_len--;
 743		audit_log_format(ab, " trawcon=");
 744		audit_log_n_untrustedstring(ab, scontext, scontext_len);
 745		kfree(scontext);
 746	}
 747}
 748
 749/*
 750 * This is the slow part of avc audit with big stack footprint.
 751 * Note that it is non-blocking and can be called from under
 752 * rcu_read_lock().
 753 */
 754noinline int slow_avc_audit(u32 ssid, u32 tsid, u16 tclass,
 755			    u32 requested, u32 audited, u32 denied, int result,
 756			    struct common_audit_data *a)
 
 757{
 758	struct common_audit_data stack_data;
 759	struct selinux_audit_data sad;
 760
 761	if (WARN_ON(!tclass || tclass >= ARRAY_SIZE(secclass_map)))
 762		return -EINVAL;
 763
 764	if (!a) {
 765		a = &stack_data;
 766		a->type = LSM_AUDIT_DATA_NONE;
 767	}
 768
 
 
 
 
 
 
 
 
 
 
 
 769	sad.tclass = tclass;
 770	sad.requested = requested;
 771	sad.ssid = ssid;
 772	sad.tsid = tsid;
 773	sad.audited = audited;
 774	sad.denied = denied;
 775	sad.result = result;
 
 776
 777	a->selinux_audit_data = &sad;
 778
 779	common_lsm_audit(a, avc_audit_pre_callback, avc_audit_post_callback);
 780	return 0;
 781}
 782
 783/**
 784 * avc_add_callback - Register a callback for security events.
 785 * @callback: callback function
 786 * @events: security events
 787 *
 788 * Register a callback function for events in the set @events.
 789 * Returns %0 on success or -%ENOMEM if insufficient memory
 790 * exists to add the callback.
 791 */
 792int __init avc_add_callback(int (*callback)(u32 event), u32 events)
 793{
 794	struct avc_callback_node *c;
 795	int rc = 0;
 796
 797	c = kmalloc(sizeof(*c), GFP_KERNEL);
 798	if (!c) {
 799		rc = -ENOMEM;
 800		goto out;
 801	}
 802
 803	c->callback = callback;
 804	c->events = events;
 805	c->next = avc_callbacks;
 806	avc_callbacks = c;
 807out:
 808	return rc;
 809}
 810
 811/**
 812 * avc_update_node - Update an AVC entry
 813 * @event : Updating event
 814 * @perms : Permission mask bits
 815 * @driver: xperm driver information
 816 * @base_perm: the base permission associated with the extended permission
 817 * @xperm: xperm permissions
 818 * @ssid: AVC entry source sid
 819 * @tsid: AVC entry target sid
 820 * @tclass : AVC entry target object class
 821 * @seqno : sequence number when decision was made
 822 * @xpd: extended_perms_decision to be added to the node
 823 * @flags: the AVC_* flags, e.g. AVC_EXTENDED_PERMS, or 0.
 824 *
 825 * if a valid AVC entry doesn't exist,this function returns -ENOENT.
 826 * if kmalloc() called internal returns NULL, this function returns -ENOMEM.
 827 * otherwise, this function updates the AVC entry. The original AVC-entry object
 828 * will release later by RCU.
 829 */
 830static int avc_update_node(u32 event, u32 perms, u8 driver, u8 base_perm,
 831			   u8 xperm, u32 ssid, u32 tsid, u16 tclass, u32 seqno,
 832			   struct extended_perms_decision *xpd, u32 flags)
 
 
 833{
 834	u32 hvalue;
 835	int rc = 0;
 836	unsigned long flag;
 837	struct avc_node *pos, *node, *orig = NULL;
 838	struct hlist_head *head;
 839	spinlock_t *lock;
 840
 841	node = avc_alloc_node();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 842	if (!node) {
 843		rc = -ENOMEM;
 844		goto out;
 845	}
 846
 847	/* Lock the target slot */
 848	hvalue = avc_hash(ssid, tsid, tclass);
 849
 850	head = &selinux_avc.avc_cache.slots[hvalue];
 851	lock = &selinux_avc.avc_cache.slots_lock[hvalue];
 852
 853	spin_lock_irqsave(lock, flag);
 854
 855	hlist_for_each_entry(pos, head, list) {
 856		if (ssid == pos->ae.ssid &&
 857		    tsid == pos->ae.tsid &&
 858		    tclass == pos->ae.tclass &&
 859		    seqno == pos->ae.avd.seqno){
 860			orig = pos;
 861			break;
 862		}
 863	}
 864
 865	if (!orig) {
 866		rc = -ENOENT;
 867		avc_node_kill(node);
 868		goto out_unlock;
 869	}
 870
 871	/*
 872	 * Copy and replace original node.
 873	 */
 874
 875	avc_node_populate(node, ssid, tsid, tclass, &orig->ae.avd);
 876
 877	if (orig->ae.xp_node) {
 878		rc = avc_xperms_populate(node, orig->ae.xp_node);
 879		if (rc) {
 880			avc_node_kill(node);
 881			goto out_unlock;
 882		}
 883	}
 884
 885	switch (event) {
 886	case AVC_CALLBACK_GRANT:
 887		node->ae.avd.allowed |= perms;
 888		if (node->ae.xp_node && (flags & AVC_EXTENDED_PERMS))
 889			avc_xperms_allow_perm(node->ae.xp_node, driver, base_perm, xperm);
 890		break;
 891	case AVC_CALLBACK_TRY_REVOKE:
 892	case AVC_CALLBACK_REVOKE:
 893		node->ae.avd.allowed &= ~perms;
 894		break;
 895	case AVC_CALLBACK_AUDITALLOW_ENABLE:
 896		node->ae.avd.auditallow |= perms;
 897		break;
 898	case AVC_CALLBACK_AUDITALLOW_DISABLE:
 899		node->ae.avd.auditallow &= ~perms;
 900		break;
 901	case AVC_CALLBACK_AUDITDENY_ENABLE:
 902		node->ae.avd.auditdeny |= perms;
 903		break;
 904	case AVC_CALLBACK_AUDITDENY_DISABLE:
 905		node->ae.avd.auditdeny &= ~perms;
 906		break;
 907	case AVC_CALLBACK_ADD_XPERMS:
 908		rc = avc_add_xperms_decision(node, xpd);
 909		if (rc) {
 910			avc_node_kill(node);
 911			goto out_unlock;
 912		}
 913		break;
 914	}
 915	avc_node_replace(node, orig);
 916out_unlock:
 917	spin_unlock_irqrestore(lock, flag);
 918out:
 919	return rc;
 920}
 921
 922/**
 923 * avc_flush - Flush the cache
 924 */
 925static void avc_flush(void)
 926{
 927	struct hlist_head *head;
 928	struct avc_node *node;
 929	spinlock_t *lock;
 930	unsigned long flag;
 931	int i;
 932
 933	for (i = 0; i < AVC_CACHE_SLOTS; i++) {
 934		head = &selinux_avc.avc_cache.slots[i];
 935		lock = &selinux_avc.avc_cache.slots_lock[i];
 936
 937		spin_lock_irqsave(lock, flag);
 938		/*
 939		 * With preemptable RCU, the outer spinlock does not
 940		 * prevent RCU grace periods from ending.
 941		 */
 942		rcu_read_lock();
 943		hlist_for_each_entry(node, head, list)
 944			avc_node_delete(node);
 945		rcu_read_unlock();
 946		spin_unlock_irqrestore(lock, flag);
 947	}
 948}
 949
 950/**
 951 * avc_ss_reset - Flush the cache and revalidate migrated permissions.
 952 * @seqno: policy sequence number
 953 */
 954int avc_ss_reset(u32 seqno)
 955{
 956	struct avc_callback_node *c;
 957	int rc = 0, tmprc;
 958
 959	avc_flush();
 960
 961	for (c = avc_callbacks; c; c = c->next) {
 962		if (c->events & AVC_CALLBACK_RESET) {
 963			tmprc = c->callback(AVC_CALLBACK_RESET);
 964			/* save the first error encountered for the return
 965			   value and continue processing the callbacks */
 966			if (!rc)
 967				rc = tmprc;
 968		}
 969	}
 970
 971	avc_latest_notif_update(seqno, 0);
 972	return rc;
 973}
 974
 975/**
 976 * avc_compute_av - Add an entry to the AVC based on the security policy
 977 * @ssid: subject
 978 * @tsid: object/target
 979 * @tclass: object class
 980 * @avd: access vector decision
 981 * @xp_node: AVC extended permissions node
 982 *
 983 * Slow-path helper function for avc_has_perm_noaudit, when the avc_node lookup
 984 * fails.  Don't inline this, since it's the slow-path and just results in a
 985 * bigger stack frame.
 986 */
 987static noinline void avc_compute_av(u32 ssid, u32 tsid, u16 tclass,
 988				    struct av_decision *avd,
 989				    struct avc_xperms_node *xp_node)
 
 
 990{
 
 991	INIT_LIST_HEAD(&xp_node->xpd_head);
 992	security_compute_av(ssid, tsid, tclass, avd, &xp_node->xp);
 993	avc_insert(ssid, tsid, tclass, avd, xp_node);
 
 994}
 995
 996static noinline int avc_denied(u32 ssid, u32 tsid, u16 tclass, u32 requested,
 997			       u8 driver, u8 base_perm, u8 xperm,
 998			       unsigned int flags, struct av_decision *avd)
 
 
 999{
1000	if (flags & AVC_STRICT)
1001		return -EACCES;
1002
1003	if (enforcing_enabled() &&
1004	    !(avd->flags & AVD_FLAGS_PERMISSIVE))
1005		return -EACCES;
1006
1007	avc_update_node(AVC_CALLBACK_GRANT, requested, driver, base_perm,
1008			xperm, ssid, tsid, tclass, avd->seqno, NULL, flags);
1009	return 0;
1010}
1011
1012/*
1013 * The avc extended permissions logic adds an additional 256 bits of
1014 * permissions to an avc node when extended permissions for that node are
1015 * specified in the avtab. If the additional 256 permissions is not adequate,
1016 * as-is the case with ioctls, then multiple may be chained together and the
1017 * driver field is used to specify which set contains the permission.
1018 */
1019int avc_has_extended_perms(u32 ssid, u32 tsid, u16 tclass, u32 requested,
1020			   u8 driver, u8 base_perm, u8 xperm,
1021			   struct common_audit_data *ad)
1022{
1023	struct avc_node *node;
1024	struct av_decision avd;
1025	u32 denied;
1026	struct extended_perms_decision local_xpd;
1027	struct extended_perms_decision *xpd = NULL;
1028	struct extended_perms_data allowed;
1029	struct extended_perms_data auditallow;
1030	struct extended_perms_data dontaudit;
1031	struct avc_xperms_node local_xp_node;
1032	struct avc_xperms_node *xp_node;
1033	int rc = 0, rc2;
1034
1035	xp_node = &local_xp_node;
1036	if (WARN_ON(!requested))
1037		return -EACCES;
1038
1039	rcu_read_lock();
1040
1041	node = avc_lookup(ssid, tsid, tclass);
1042	if (unlikely(!node)) {
1043		avc_compute_av(ssid, tsid, tclass, &avd, xp_node);
1044	} else {
1045		memcpy(&avd, &node->ae.avd, sizeof(avd));
1046		xp_node = node->ae.xp_node;
1047	}
1048	/* if extended permissions are not defined, only consider av_decision */
1049	if (!xp_node || !xp_node->xp.len)
1050		goto decision;
1051
1052	local_xpd.allowed = &allowed;
1053	local_xpd.auditallow = &auditallow;
1054	local_xpd.dontaudit = &dontaudit;
1055
1056	xpd = avc_xperms_decision_lookup(driver, base_perm, xp_node);
1057	if (unlikely(!xpd)) {
1058		/*
1059		 * Compute the extended_perms_decision only if the driver
1060		 * is flagged and the base permission is known.
1061		 */
1062		if (!security_xperm_test(xp_node->xp.drivers.p, driver) ||
1063		    !(xp_node->xp.base_perms & base_perm)) {
1064			avd.allowed &= ~requested;
1065			goto decision;
1066		}
1067		rcu_read_unlock();
1068		security_compute_xperms_decision(ssid, tsid, tclass, driver,
1069						 base_perm, &local_xpd);
1070		rcu_read_lock();
1071		avc_update_node(AVC_CALLBACK_ADD_XPERMS, requested, driver,
1072				base_perm, xperm, ssid, tsid, tclass, avd.seqno,
1073				&local_xpd, 0);
1074	} else {
1075		avc_quick_copy_xperms_decision(xperm, &local_xpd, xpd);
1076	}
1077	xpd = &local_xpd;
1078
1079	if (!avc_xperms_has_perm(xpd, xperm, XPERMS_ALLOWED))
1080		avd.allowed &= ~requested;
1081
1082decision:
1083	denied = requested & ~(avd.allowed);
1084	if (unlikely(denied))
1085		rc = avc_denied(ssid, tsid, tclass, requested, driver,
1086				base_perm, xperm, AVC_EXTENDED_PERMS, &avd);
1087
1088	rcu_read_unlock();
1089
1090	rc2 = avc_xperms_audit(ssid, tsid, tclass, requested,
1091			&avd, xpd, xperm, rc, ad);
1092	if (rc2)
1093		return rc2;
1094	return rc;
1095}
1096
1097/**
1098 * avc_perm_nonode - Add an entry to the AVC
1099 * @ssid: subject
1100 * @tsid: object/target
1101 * @tclass: object class
1102 * @requested: requested permissions
1103 * @flags: AVC flags
1104 * @avd: access vector decision
1105 *
1106 * This is the "we have no node" part of avc_has_perm_noaudit(), which is
1107 * unlikely and needs extra stack space for the new node that we generate, so
1108 * don't inline it.
1109 */
1110static noinline int avc_perm_nonode(u32 ssid, u32 tsid, u16 tclass,
1111				    u32 requested, unsigned int flags,
1112				    struct av_decision *avd)
1113{
1114	u32 denied;
1115	struct avc_xperms_node xp_node;
1116
1117	avc_compute_av(ssid, tsid, tclass, avd, &xp_node);
1118	denied = requested & ~(avd->allowed);
1119	if (unlikely(denied))
1120		return avc_denied(ssid, tsid, tclass, requested, 0, 0, 0,
1121				  flags, avd);
1122	return 0;
1123}
1124
1125/**
1126 * avc_has_perm_noaudit - Check permissions but perform no auditing.
1127 * @ssid: source security identifier
1128 * @tsid: target security identifier
1129 * @tclass: target security class
1130 * @requested: requested permissions, interpreted based on @tclass
1131 * @flags:  AVC_STRICT or 0
1132 * @avd: access vector decisions
1133 *
1134 * Check the AVC to determine whether the @requested permissions are granted
1135 * for the SID pair (@ssid, @tsid), interpreting the permissions
1136 * based on @tclass, and call the security server on a cache miss to obtain
1137 * a new decision and add it to the cache.  Return a copy of the decisions
1138 * in @avd.  Return %0 if all @requested permissions are granted,
1139 * -%EACCES if any permissions are denied, or another -errno upon
1140 * other errors.  This function is typically called by avc_has_perm(),
1141 * but may also be called directly to separate permission checking from
1142 * auditing, e.g. in cases where a lock must be held for the check but
1143 * should be released for the auditing.
1144 */
1145inline int avc_has_perm_noaudit(u32 ssid, u32 tsid,
 
1146				u16 tclass, u32 requested,
1147				unsigned int flags,
1148				struct av_decision *avd)
1149{
 
 
 
1150	u32 denied;
1151	struct avc_node *node;
1152
1153	if (WARN_ON(!requested))
1154		return -EACCES;
1155
1156	rcu_read_lock();
1157	node = avc_lookup(ssid, tsid, tclass);
1158	if (unlikely(!node)) {
1159		rcu_read_unlock();
1160		return avc_perm_nonode(ssid, tsid, tclass, requested,
1161				       flags, avd);
1162	}
1163	denied = requested & ~node->ae.avd.allowed;
1164	memcpy(avd, &node->ae.avd, sizeof(*avd));
1165	rcu_read_unlock();
1166
 
 
 
 
 
 
 
1167	if (unlikely(denied))
1168		return avc_denied(ssid, tsid, tclass, requested, 0, 0, 0,
1169				  flags, avd);
1170	return 0;
 
 
1171}
1172
1173/**
1174 * avc_has_perm - Check permissions and perform any appropriate auditing.
1175 * @ssid: source security identifier
1176 * @tsid: target security identifier
1177 * @tclass: target security class
1178 * @requested: requested permissions, interpreted based on @tclass
1179 * @auditdata: auxiliary audit data
1180 *
1181 * Check the AVC to determine whether the @requested permissions are granted
1182 * for the SID pair (@ssid, @tsid), interpreting the permissions
1183 * based on @tclass, and call the security server on a cache miss to obtain
1184 * a new decision and add it to the cache.  Audit the granting or denial of
1185 * permissions in accordance with the policy.  Return %0 if all @requested
1186 * permissions are granted, -%EACCES if any permissions are denied, or
1187 * another -errno upon other errors.
1188 */
1189int avc_has_perm(u32 ssid, u32 tsid, u16 tclass,
1190		 u32 requested, struct common_audit_data *auditdata)
1191{
1192	struct av_decision avd;
1193	int rc, rc2;
1194
1195	rc = avc_has_perm_noaudit(ssid, tsid, tclass, requested, 0,
1196				  &avd);
1197
1198	rc2 = avc_audit(ssid, tsid, tclass, requested, &avd, rc,
1199			auditdata);
1200	if (rc2)
1201		return rc2;
1202	return rc;
1203}
1204
1205u32 avc_policy_seqno(void)
 
 
 
 
 
1206{
1207	return selinux_avc.avc_cache.latest_notif;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1208}