smack_lsm.c 84.1 KB
Newer Older
1 2 3 4 5
/*
 *  Simplified MAC Kernel (smack) security module
 *
 *  This file contains the smack hook function implementations.
 *
6
 *  Authors:
7
 *	Casey Schaufler <casey@schaufler-ca.com>
8
 *	Jarkko Sakkinen <jarkko.sakkinen@intel.com>
9 10
 *
 *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
11
 *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
12
 *                Paul Moore <paul@paul-moore.com>
13
 *  Copyright (C) 2010 Nokia Corporation
14
 *  Copyright (C) 2011 Intel Corporation.
15 16 17 18 19 20 21 22 23 24 25 26
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License version 2,
 *      as published by the Free Software Foundation.
 */

#include <linux/xattr.h>
#include <linux/pagemap.h>
#include <linux/mount.h>
#include <linux/stat.h>
#include <linux/kd.h>
#include <asm/ioctls.h>
27
#include <linux/ip.h>
28 29
#include <linux/tcp.h>
#include <linux/udp.h>
30
#include <linux/slab.h>
31 32 33
#include <linux/mutex.h>
#include <linux/pipe_fs_i.h>
#include <net/cipso_ipv4.h>
34
#include <linux/audit.h>
N
Nick Black 已提交
35
#include <linux/magic.h>
36
#include <linux/dcache.h>
J
Jarkko Sakkinen 已提交
37
#include <linux/personality.h>
A
Al Viro 已提交
38 39 40
#include <linux/msg.h>
#include <linux/shm.h>
#include <linux/binfmts.h>
41 42
#include "smack.h"

43 44
#define task_security(task)	(task_cred_xxx((task), security))

45 46 47
#define TRANS_TRUE	"TRUE"
#define TRANS_TRUE_SIZE	4

48 49 50 51 52 53 54 55
/**
 * smk_fetch - Fetch the smack label from a file.
 * @ip: a pointer to the inode
 * @dp: a pointer to the dentry
 *
 * Returns a pointer to the master list entry for the Smack label
 * or NULL if there was no label to fetch.
 */
56
static char *smk_fetch(const char *name, struct inode *ip, struct dentry *dp)
57 58
{
	int rc;
59 60
	char *buffer;
	char *result = NULL;
61 62 63 64

	if (ip->i_op->getxattr == NULL)
		return NULL;

65 66
	buffer = kzalloc(SMK_LONGLABEL, GFP_KERNEL);
	if (buffer == NULL)
67 68
		return NULL;

69 70 71 72 73 74 75
	rc = ip->i_op->getxattr(dp, name, buffer, SMK_LONGLABEL);
	if (rc > 0)
		result = smk_import(buffer, rc);

	kfree(buffer);

	return result;
76 77 78 79 80 81 82 83 84 85 86 87
}

/**
 * new_inode_smack - allocate an inode security blob
 * @smack: a pointer to the Smack label to use in the blob
 *
 * Returns the new blob or NULL if there's no memory available
 */
struct inode_smack *new_inode_smack(char *smack)
{
	struct inode_smack *isp;

88
	isp = kzalloc(sizeof(struct inode_smack), GFP_NOFS);
89 90 91 92 93 94 95 96 97 98
	if (isp == NULL)
		return NULL;

	isp->smk_inode = smack;
	isp->smk_flags = 0;
	mutex_init(&isp->smk_lock);

	return isp;
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
/**
 * new_task_smack - allocate a task security blob
 * @smack: a pointer to the Smack label to use in the blob
 *
 * Returns the new blob or NULL if there's no memory available
 */
static struct task_smack *new_task_smack(char *task, char *forked, gfp_t gfp)
{
	struct task_smack *tsp;

	tsp = kzalloc(sizeof(struct task_smack), gfp);
	if (tsp == NULL)
		return NULL;

	tsp->smk_task = task;
	tsp->smk_forked = forked;
	INIT_LIST_HEAD(&tsp->smk_rules);
	mutex_init(&tsp->smk_rules_lock);

	return tsp;
}

/**
 * smk_copy_rules - copy a rule set
 * @nhead - new rules header pointer
 * @ohead - old rules header pointer
 *
 * Returns 0 on success, -ENOMEM on error
 */
static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
				gfp_t gfp)
{
	struct smack_rule *nrp;
	struct smack_rule *orp;
	int rc = 0;

	INIT_LIST_HEAD(nhead);

	list_for_each_entry_rcu(orp, ohead, list) {
		nrp = kzalloc(sizeof(struct smack_rule), gfp);
		if (nrp == NULL) {
			rc = -ENOMEM;
			break;
		}
		*nrp = *orp;
		list_add_rcu(&nrp->list, nhead);
	}
	return rc;
}

149 150 151 152 153 154
/*
 * LSM hooks.
 * We he, that is fun!
 */

/**
155
 * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH
156
 * @ctp: child task pointer
157
 * @mode: ptrace attachment mode
158 159 160 161 162
 *
 * Returns 0 if access is OK, an error code otherwise
 *
 * Do the capability checks, and require read and write.
 */
163
static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
164 165
{
	int rc;
E
Etienne Basset 已提交
166
	struct smk_audit_info ad;
167
	char *tsp;
168

169
	rc = cap_ptrace_access_check(ctp, mode);
170 171 172
	if (rc != 0)
		return rc;

173
	tsp = smk_of_task(task_security(ctp));
E
Etienne Basset 已提交
174 175 176
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
	smk_ad_setfield_u_tsk(&ad, ctp);

177
	rc = smk_curacc(tsp, MAY_READWRITE, &ad);
178 179 180 181 182 183 184 185 186 187 188 189 190 191
	return rc;
}

/**
 * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
 * @ptp: parent task pointer
 *
 * Returns 0 if access is OK, an error code otherwise
 *
 * Do the capability checks, and require read and write.
 */
static int smack_ptrace_traceme(struct task_struct *ptp)
{
	int rc;
E
Etienne Basset 已提交
192
	struct smk_audit_info ad;
193
	char *tsp;
194 195 196 197

	rc = cap_ptrace_traceme(ptp);
	if (rc != 0)
		return rc;
198

199
	tsp = smk_of_task(task_security(ptp));
E
Etienne Basset 已提交
200 201 202
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
	smk_ad_setfield_u_tsk(&ad, ptp);

203
	rc = smk_curacc(tsp, MAY_READWRITE, &ad);
204 205 206 207 208 209 210 211 212 213 214
	return rc;
}

/**
 * smack_syslog - Smack approval on syslog
 * @type: message type
 *
 * Require that the task has the floor label
 *
 * Returns 0 on success, error code otherwise.
 */
215
static int smack_syslog(int typefrom_file)
216
{
217
	int rc = 0;
218
	char *sp = smk_of_current();
219

220
	if (smack_privileged(CAP_MAC_OVERRIDE))
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
		return 0;

	 if (sp != smack_known_floor.smk_known)
		rc = -EACCES;

	return rc;
}


/*
 * Superblock Hooks.
 */

/**
 * smack_sb_alloc_security - allocate a superblock blob
 * @sb: the superblock getting the blob
 *
 * Returns 0 on success or -ENOMEM on error.
 */
static int smack_sb_alloc_security(struct super_block *sb)
{
	struct superblock_smack *sbsp;

	sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);

	if (sbsp == NULL)
		return -ENOMEM;

	sbsp->smk_root = smack_known_floor.smk_known;
	sbsp->smk_default = smack_known_floor.smk_known;
	sbsp->smk_floor = smack_known_floor.smk_known;
	sbsp->smk_hat = smack_known_hat.smk_known;
	sbsp->smk_initialized = 0;

	sb->s_security = sbsp;

	return 0;
}

/**
 * smack_sb_free_security - free a superblock blob
 * @sb: the superblock getting the blob
 *
 */
static void smack_sb_free_security(struct super_block *sb)
{
	kfree(sb->s_security);
	sb->s_security = NULL;
}

/**
 * smack_sb_copy_data - copy mount options data for processing
 * @orig: where to start
274
 * @smackopts: mount options string
275 276 277 278 279 280
 *
 * Returns 0 on success or -ENOMEM on error.
 *
 * Copy the Smack specific mount options out of the mount
 * options list.
 */
281
static int smack_sb_copy_data(char *orig, char *smackopts)
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
{
	char *cp, *commap, *otheropts, *dp;

	otheropts = (char *)get_zeroed_page(GFP_KERNEL);
	if (otheropts == NULL)
		return -ENOMEM;

	for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
		if (strstr(cp, SMK_FSDEFAULT) == cp)
			dp = smackopts;
		else if (strstr(cp, SMK_FSFLOOR) == cp)
			dp = smackopts;
		else if (strstr(cp, SMK_FSHAT) == cp)
			dp = smackopts;
		else if (strstr(cp, SMK_FSROOT) == cp)
			dp = smackopts;
		else
			dp = otheropts;

		commap = strchr(cp, ',');
		if (commap != NULL)
			*commap = '\0';

		if (*dp != '\0')
			strcat(dp, ",");
		strcat(dp, cp);
	}

	strcpy(orig, otheropts);
	free_page((unsigned long)otheropts);

	return 0;
}

/**
 * smack_sb_kern_mount - Smack specific mount processing
 * @sb: the file system superblock
319
 * @flags: the mount flags
320 321 322 323
 * @data: the smack mount options
 *
 * Returns 0 on success, an error code on failure
 */
324
static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
325 326 327 328 329 330 331 332 333
{
	struct dentry *root = sb->s_root;
	struct inode *inode = root->d_inode;
	struct superblock_smack *sp = sb->s_security;
	struct inode_smack *isp;
	char *op;
	char *commap;
	char *nsp;

334
	if (sp->smk_initialized != 0)
335
		return 0;
336

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
	sp->smk_initialized = 1;

	for (op = data; op != NULL; op = commap) {
		commap = strchr(op, ',');
		if (commap != NULL)
			*commap++ = '\0';

		if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
			op += strlen(SMK_FSHAT);
			nsp = smk_import(op, 0);
			if (nsp != NULL)
				sp->smk_hat = nsp;
		} else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
			op += strlen(SMK_FSFLOOR);
			nsp = smk_import(op, 0);
			if (nsp != NULL)
				sp->smk_floor = nsp;
		} else if (strncmp(op, SMK_FSDEFAULT,
				   strlen(SMK_FSDEFAULT)) == 0) {
			op += strlen(SMK_FSDEFAULT);
			nsp = smk_import(op, 0);
			if (nsp != NULL)
				sp->smk_default = nsp;
		} else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
			op += strlen(SMK_FSROOT);
			nsp = smk_import(op, 0);
			if (nsp != NULL)
				sp->smk_root = nsp;
		}
	}

	/*
	 * Initialize the root inode.
	 */
	isp = inode->i_security;
	if (isp == NULL)
		inode->i_security = new_inode_smack(sp->smk_root);
	else
		isp->smk_inode = sp->smk_root;

	return 0;
}

/**
 * smack_sb_statfs - Smack check on statfs
 * @dentry: identifies the file system in question
 *
 * Returns 0 if current can read the floor of the filesystem,
 * and error code otherwise
 */
static int smack_sb_statfs(struct dentry *dentry)
{
	struct superblock_smack *sbp = dentry->d_sb->s_security;
E
Etienne Basset 已提交
390 391 392
	int rc;
	struct smk_audit_info ad;

393
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
394
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
395

E
Etienne Basset 已提交
396 397
	rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
	return rc;
398 399 400 401 402
}

/**
 * smack_sb_mount - Smack check for mounting
 * @dev_name: unused
403
 * @path: mount point
404 405 406 407 408 409 410
 * @type: unused
 * @flags: unused
 * @data: unused
 *
 * Returns 0 if current can write the floor of the filesystem
 * being mounted on, an error code otherwise.
 */
A
Al Viro 已提交
411 412
static int smack_sb_mount(const char *dev_name, struct path *path,
			  const char *type, unsigned long flags, void *data)
413
{
414
	struct superblock_smack *sbp = path->dentry->d_sb->s_security;
E
Etienne Basset 已提交
415
	struct smk_audit_info ad;
416

417
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
E
Etienne Basset 已提交
418 419 420
	smk_ad_setfield_u_fs_path(&ad, *path);

	return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
421 422 423 424 425 426 427 428 429 430 431 432 433
}

/**
 * smack_sb_umount - Smack check for unmounting
 * @mnt: file system to unmount
 * @flags: unused
 *
 * Returns 0 if current can write the floor of the filesystem
 * being unmounted, an error code otherwise.
 */
static int smack_sb_umount(struct vfsmount *mnt, int flags)
{
	struct superblock_smack *sbp;
E
Etienne Basset 已提交
434
	struct smk_audit_info ad;
435
	struct path path;
436

437 438
	path.dentry = mnt->mnt_root;
	path.mnt = mnt;
439

440
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
441
	smk_ad_setfield_u_fs_path(&ad, path);
442

443
	sbp = path.dentry->d_sb->s_security;
E
Etienne Basset 已提交
444
	return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
445 446
}

447 448 449 450
/*
 * BPRM hooks
 */

C
Casey Schaufler 已提交
451 452 453 454 455 456
/**
 * smack_bprm_set_creds - set creds for exec
 * @bprm: the exec information
 *
 * Returns 0 if it gets a blob, -ENOMEM otherwise
 */
457 458
static int smack_bprm_set_creds(struct linux_binprm *bprm)
{
A
Al Viro 已提交
459
	struct inode *inode = file_inode(bprm->file);
460
	struct task_smack *bsp = bprm->cred->security;
461 462 463 464 465 466 467 468 469 470
	struct inode_smack *isp;
	int rc;

	rc = cap_bprm_set_creds(bprm);
	if (rc != 0)
		return rc;

	if (bprm->cred_prepared)
		return 0;

471 472
	isp = inode->i_security;
	if (isp->smk_task == NULL || isp->smk_task == bsp->smk_task)
473 474
		return 0;

475 476
	if (bprm->unsafe)
		return -EPERM;
477

478 479
	bsp->smk_task = isp->smk_task;
	bprm->per_clear |= PER_CLEAR_ON_SETID;
480

481 482
	return 0;
}
483

484 485 486 487 488 489 490 491 492
/**
 * smack_bprm_committing_creds - Prepare to install the new credentials
 * from bprm.
 *
 * @bprm: binprm for exec
 */
static void smack_bprm_committing_creds(struct linux_binprm *bprm)
{
	struct task_smack *bsp = bprm->cred->security;
493

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
	if (bsp->smk_task != bsp->smk_forked)
		current->pdeath_signal = 0;
}

/**
 * smack_bprm_secureexec - Return the decision to use secureexec.
 * @bprm: binprm for exec
 *
 * Returns 0 on success.
 */
static int smack_bprm_secureexec(struct linux_binprm *bprm)
{
	struct task_smack *tsp = current_security();
	int ret = cap_bprm_secureexec(bprm);

	if (!ret && (tsp->smk_task != tsp->smk_forked))
		ret = 1;

	return ret;
513 514
}

515 516 517 518 519 520
/*
 * Inode hooks
 */

/**
 * smack_inode_alloc_security - allocate an inode blob
521
 * @inode: the inode in need of a blob
522 523 524 525 526
 *
 * Returns 0 if it gets a blob, -ENOMEM otherwise
 */
static int smack_inode_alloc_security(struct inode *inode)
{
527
	inode->i_security = new_inode_smack(smk_of_current());
528 529 530 531 532 533 534
	if (inode->i_security == NULL)
		return -ENOMEM;
	return 0;
}

/**
 * smack_inode_free_security - free an inode blob
535
 * @inode: the inode with a blob
536 537 538 539 540 541 542 543 544 545 546 547 548
 *
 * Clears the blob pointer in inode
 */
static void smack_inode_free_security(struct inode *inode)
{
	kfree(inode->i_security);
	inode->i_security = NULL;
}

/**
 * smack_inode_init_security - copy out the smack from an inode
 * @inode: the inode
 * @dir: unused
549
 * @qstr: unused
550 551 552 553 554 555 556
 * @name: where to put the attribute name
 * @value: where to put the attribute value
 * @len: where to put the length of the attribute
 *
 * Returns 0 if it all works out, -ENOMEM if there's no memory
 */
static int smack_inode_init_security(struct inode *inode, struct inode *dir,
557 558
				     const struct qstr *qstr, char **name,
				     void **value, size_t *len)
559
{
560
	struct smack_known *skp;
C
Casey Schaufler 已提交
561
	struct inode_smack *issp = inode->i_security;
562
	char *csp = smk_of_current();
563
	char *isp = smk_of_inode(inode);
564
	char *dsp = smk_of_inode(dir);
565
	int may;
566 567

	if (name) {
568
		*name = kstrdup(XATTR_SMACK_SUFFIX, GFP_NOFS);
569 570 571 572 573
		if (*name == NULL)
			return -ENOMEM;
	}

	if (value) {
574
		skp = smk_find_entry(csp);
575
		rcu_read_lock();
576
		may = smk_access_entry(csp, dsp, &skp->smk_rules);
577
		rcu_read_unlock();
578 579 580 581 582

		/*
		 * If the access rule allows transmutation and
		 * the directory requests transmutation then
		 * by all means transmute.
C
Casey Schaufler 已提交
583
		 * Mark the inode as changed.
584
		 */
585
		if (may > 0 && ((may & MAY_TRANSMUTE) != 0) &&
C
Casey Schaufler 已提交
586
		    smk_inode_transmutable(dir)) {
587
			isp = dsp;
C
Casey Schaufler 已提交
588 589
			issp->smk_flags |= SMK_INODE_CHANGED;
		}
590

591
		*value = kstrdup(isp, GFP_NOFS);
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
		if (*value == NULL)
			return -ENOMEM;
	}

	if (len)
		*len = strlen(isp) + 1;

	return 0;
}

/**
 * smack_inode_link - Smack check on link
 * @old_dentry: the existing object
 * @dir: unused
 * @new_dentry: the new object
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
			    struct dentry *new_dentry)
{
	char *isp;
E
Etienne Basset 已提交
614 615 616
	struct smk_audit_info ad;
	int rc;

617
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
618
	smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
619 620

	isp = smk_of_inode(old_dentry->d_inode);
E
Etienne Basset 已提交
621
	rc = smk_curacc(isp, MAY_WRITE, &ad);
622 623 624

	if (rc == 0 && new_dentry->d_inode != NULL) {
		isp = smk_of_inode(new_dentry->d_inode);
E
Etienne Basset 已提交
625 626
		smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
		rc = smk_curacc(isp, MAY_WRITE, &ad);
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
	}

	return rc;
}

/**
 * smack_inode_unlink - Smack check on inode deletion
 * @dir: containing directory object
 * @dentry: file to unlink
 *
 * Returns 0 if current can write the containing directory
 * and the object, error code otherwise
 */
static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
{
	struct inode *ip = dentry->d_inode;
E
Etienne Basset 已提交
643
	struct smk_audit_info ad;
644 645
	int rc;

646
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
647 648
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

649 650 651
	/*
	 * You need write access to the thing you're unlinking
	 */
E
Etienne Basset 已提交
652 653
	rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
	if (rc == 0) {
654 655 656
		/*
		 * You also need write access to the containing directory
		 */
E
Etienne Basset 已提交
657 658 659 660
		smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
		smk_ad_setfield_u_fs_inode(&ad, dir);
		rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
	}
661 662 663 664 665 666 667 668 669 670 671 672 673
	return rc;
}

/**
 * smack_inode_rmdir - Smack check on directory deletion
 * @dir: containing directory object
 * @dentry: directory to unlink
 *
 * Returns 0 if current can write the containing directory
 * and the directory, error code otherwise
 */
static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
{
E
Etienne Basset 已提交
674
	struct smk_audit_info ad;
675 676
	int rc;

677
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
678 679
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

680 681 682
	/*
	 * You need write access to the thing you're removing
	 */
E
Etienne Basset 已提交
683 684
	rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
	if (rc == 0) {
685 686 687
		/*
		 * You also need write access to the containing directory
		 */
E
Etienne Basset 已提交
688 689 690 691
		smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
		smk_ad_setfield_u_fs_inode(&ad, dir);
		rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
	}
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714

	return rc;
}

/**
 * smack_inode_rename - Smack check on rename
 * @old_inode: the old directory
 * @old_dentry: unused
 * @new_inode: the new directory
 * @new_dentry: unused
 *
 * Read and write access is required on both the old and
 * new directories.
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_rename(struct inode *old_inode,
			      struct dentry *old_dentry,
			      struct inode *new_inode,
			      struct dentry *new_dentry)
{
	int rc;
	char *isp;
E
Etienne Basset 已提交
715 716
	struct smk_audit_info ad;

717
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
718
	smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
719 720

	isp = smk_of_inode(old_dentry->d_inode);
E
Etienne Basset 已提交
721
	rc = smk_curacc(isp, MAY_READWRITE, &ad);
722 723 724

	if (rc == 0 && new_dentry->d_inode != NULL) {
		isp = smk_of_inode(new_dentry->d_inode);
E
Etienne Basset 已提交
725 726
		smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
		rc = smk_curacc(isp, MAY_READWRITE, &ad);
727 728 729 730 731 732 733 734 735 736 737 738 739
	}
	return rc;
}

/**
 * smack_inode_permission - Smack version of permission()
 * @inode: the inode in question
 * @mask: the access requested
 *
 * This is the important Smack hook.
 *
 * Returns 0 if access is permitted, -EACCES otherwise
 */
740
static int smack_inode_permission(struct inode *inode, int mask)
741
{
E
Etienne Basset 已提交
742
	struct smk_audit_info ad;
743
	int no_block = mask & MAY_NOT_BLOCK;
744 745

	mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
746 747 748 749 750
	/*
	 * No permission to check. Existence test. Yup, it's there.
	 */
	if (mask == 0)
		return 0;
751 752

	/* May be droppable after audit */
753
	if (no_block)
754
		return -ECHILD;
755
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
E
Etienne Basset 已提交
756 757
	smk_ad_setfield_u_fs_inode(&ad, inode);
	return smk_curacc(smk_of_inode(inode), mask, &ad);
758 759 760 761 762 763 764 765 766 767 768
}

/**
 * smack_inode_setattr - Smack check for setting attributes
 * @dentry: the object
 * @iattr: for the force flag
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
{
E
Etienne Basset 已提交
769
	struct smk_audit_info ad;
770 771 772 773 774
	/*
	 * Need to allow for clearing the setuid bit.
	 */
	if (iattr->ia_valid & ATTR_FORCE)
		return 0;
775
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
776
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
777

E
Etienne Basset 已提交
778
	return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
779 780 781 782 783 784 785 786 787 788 789
}

/**
 * smack_inode_getattr - Smack check for getting attributes
 * @mnt: unused
 * @dentry: the object
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
{
E
Etienne Basset 已提交
790
	struct smk_audit_info ad;
791
	struct path path;
E
Etienne Basset 已提交
792

793 794
	path.dentry = dentry;
	path.mnt = mnt;
E
Etienne Basset 已提交
795

796
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
797
	smk_ad_setfield_u_fs_path(&ad, path);
E
Etienne Basset 已提交
798
	return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
799 800 801 802 803 804 805 806 807 808 809 810 811 812
}

/**
 * smack_inode_setxattr - Smack check for setting xattrs
 * @dentry: the object
 * @name: name of the attribute
 * @value: unused
 * @size: unused
 * @flags: unused
 *
 * This protects the Smack attribute explicitly.
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
813 814
static int smack_inode_setxattr(struct dentry *dentry, const char *name,
				const void *value, size_t size, int flags)
815
{
E
Etienne Basset 已提交
816
	struct smk_audit_info ad;
817
	int rc = 0;
818

819 820
	if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
	    strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
821
	    strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
822 823
	    strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
	    strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
824
		if (!smack_privileged(CAP_MAC_ADMIN))
825
			rc = -EPERM;
826 827 828 829
		/*
		 * check label validity here so import wont fail on
		 * post_setxattr
		 */
830
		if (size == 0 || size >= SMK_LONGLABEL ||
831
		    smk_import(value, size) == NULL)
832
			rc = -EINVAL;
833
	} else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
834
		if (!smack_privileged(CAP_MAC_ADMIN))
835 836 837 838
			rc = -EPERM;
		if (size != TRANS_TRUE_SIZE ||
		    strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0)
			rc = -EINVAL;
839 840 841
	} else
		rc = cap_inode_setxattr(dentry, name, value, size, flags);

842
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
843 844
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

845
	if (rc == 0)
E
Etienne Basset 已提交
846
		rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
847 848

	return rc;
849 850 851 852 853 854 855 856 857 858 859 860 861
}

/**
 * smack_inode_post_setxattr - Apply the Smack update approved above
 * @dentry: object
 * @name: attribute name
 * @value: attribute value
 * @size: attribute size
 * @flags: unused
 *
 * Set the pointer in the inode blob to the entry found
 * in the master label list.
 */
862 863
static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
				      const void *value, size_t size, int flags)
864 865
{
	char *nsp;
866
	struct inode_smack *isp = dentry->d_inode->i_security;
867 868

	if (strcmp(name, XATTR_NAME_SMACK) == 0) {
869
		nsp = smk_import(value, size);
870 871 872 873
		if (nsp != NULL)
			isp->smk_inode = nsp;
		else
			isp->smk_inode = smack_known_invalid.smk_known;
874 875
	} else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) {
		nsp = smk_import(value, size);
876 877 878 879
		if (nsp != NULL)
			isp->smk_task = nsp;
		else
			isp->smk_task = smack_known_invalid.smk_known;
880 881 882 883 884 885
	} else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
		nsp = smk_import(value, size);
		if (nsp != NULL)
			isp->smk_mmap = nsp;
		else
			isp->smk_mmap = smack_known_invalid.smk_known;
886 887
	} else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0)
		isp->smk_flags |= SMK_INODE_TRANSMUTE;
888 889 890 891

	return;
}

C
Casey Schaufler 已提交
892
/**
893 894 895 896 897 898
 * smack_inode_getxattr - Smack check on getxattr
 * @dentry: the object
 * @name: unused
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
899
static int smack_inode_getxattr(struct dentry *dentry, const char *name)
900
{
E
Etienne Basset 已提交
901 902
	struct smk_audit_info ad;

903
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
904 905 906
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

	return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
907 908
}

C
Casey Schaufler 已提交
909
/**
910 911 912 913 914 915 916 917
 * smack_inode_removexattr - Smack check on removexattr
 * @dentry: the object
 * @name: name of the attribute
 *
 * Removing the Smack attribute requires CAP_MAC_ADMIN
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
918
static int smack_inode_removexattr(struct dentry *dentry, const char *name)
919
{
920
	struct inode_smack *isp;
E
Etienne Basset 已提交
921
	struct smk_audit_info ad;
922
	int rc = 0;
923

924 925
	if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
	    strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
926
	    strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
927
	    strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
928 929
	    strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
	    strcmp(name, XATTR_NAME_SMACKMMAP)) {
930
		if (!smack_privileged(CAP_MAC_ADMIN))
931 932 933 934
			rc = -EPERM;
	} else
		rc = cap_inode_removexattr(dentry, name);

935
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
E
Etienne Basset 已提交
936
	smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
937
	if (rc == 0)
E
Etienne Basset 已提交
938
		rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
939

940 941 942
	if (rc == 0) {
		isp = dentry->d_inode->i_security;
		isp->smk_task = NULL;
943
		isp->smk_mmap = NULL;
944 945
	}

946
	return rc;
947 948 949 950 951 952 953
}

/**
 * smack_inode_getsecurity - get smack xattrs
 * @inode: the object
 * @name: attribute name
 * @buffer: where to put the result
954
 * @alloc: unused
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
 *
 * Returns the size of the attribute or an error code
 */
static int smack_inode_getsecurity(const struct inode *inode,
				   const char *name, void **buffer,
				   bool alloc)
{
	struct socket_smack *ssp;
	struct socket *sock;
	struct super_block *sbp;
	struct inode *ip = (struct inode *)inode;
	char *isp;
	int ilen;
	int rc = 0;

	if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
		isp = smk_of_inode(inode);
		ilen = strlen(isp) + 1;
		*buffer = isp;
		return ilen;
	}

	/*
	 * The rest of the Smack xattrs are only on sockets.
	 */
	sbp = ip->i_sb;
	if (sbp->s_magic != SOCKFS_MAGIC)
		return -EOPNOTSUPP;

	sock = SOCKET_I(ip);
985
	if (sock == NULL || sock->sk == NULL)
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
		return -EOPNOTSUPP;

	ssp = sock->sk->sk_security;

	if (strcmp(name, XATTR_SMACK_IPIN) == 0)
		isp = ssp->smk_in;
	else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
		isp = ssp->smk_out;
	else
		return -EOPNOTSUPP;

	ilen = strlen(isp) + 1;
	if (rc == 0) {
		*buffer = isp;
		rc = ilen;
	}

	return rc;
}


/**
 * smack_inode_listsecurity - list the Smack attributes
 * @inode: the object
 * @buffer: where they go
 * @buffer_size: size of buffer
 *
 * Returns 0 on success, -EINVAL otherwise
 */
static int smack_inode_listsecurity(struct inode *inode, char *buffer,
				    size_t buffer_size)
{
	int len = strlen(XATTR_NAME_SMACK);

	if (buffer != NULL && len <= buffer_size) {
		memcpy(buffer, XATTR_NAME_SMACK, len);
		return len;
	}
	return -EINVAL;
}

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
/**
 * smack_inode_getsecid - Extract inode's security id
 * @inode: inode to extract the info from
 * @secid: where result will be saved
 */
static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
{
	struct inode_smack *isp = inode->i_security;

	*secid = smack_to_secid(isp->smk_inode);
}

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
/*
 * File Hooks
 */

/**
 * smack_file_permission - Smack check on file operations
 * @file: unused
 * @mask: unused
 *
 * Returns 0
 *
 * Should access checks be done on each read or write?
 * UNICOS and SELinux say yes.
 * Trusted Solaris, Trusted Irix, and just about everyone else says no.
 *
 * I'll say no for now. Smack does not do the frequent
 * label changing that SELinux does.
 */
static int smack_file_permission(struct file *file, int mask)
{
	return 0;
}

/**
 * smack_file_alloc_security - assign a file security blob
 * @file: the object
 *
 * The security blob for a file is a pointer to the master
 * label list, so no allocation is done.
 *
 * Returns 0
 */
static int smack_file_alloc_security(struct file *file)
{
1073
	file->f_security = smk_of_current();
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
	return 0;
}

/**
 * smack_file_free_security - clear a file security blob
 * @file: the object
 *
 * The security blob for a file is a pointer to the master
 * label list, so no memory is freed.
 */
static void smack_file_free_security(struct file *file)
{
	file->f_security = NULL;
}

/**
 * smack_file_ioctl - Smack check on ioctls
 * @file: the object
 * @cmd: what to do
 * @arg: unused
 *
 * Relies heavily on the correct use of the ioctl command conventions.
 *
 * Returns 0 if allowed, error code otherwise
 */
static int smack_file_ioctl(struct file *file, unsigned int cmd,
			    unsigned long arg)
{
	int rc = 0;
E
Etienne Basset 已提交
1103 1104
	struct smk_audit_info ad;

1105
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
E
Etienne Basset 已提交
1106
	smk_ad_setfield_u_fs_path(&ad, file->f_path);
1107 1108

	if (_IOC_DIR(cmd) & _IOC_WRITE)
E
Etienne Basset 已提交
1109
		rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1110 1111

	if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
E
Etienne Basset 已提交
1112
		rc = smk_curacc(file->f_security, MAY_READ, &ad);
1113 1114 1115 1116 1117 1118 1119

	return rc;
}

/**
 * smack_file_lock - Smack check on file locking
 * @file: the object
1120
 * @cmd: unused
1121 1122 1123 1124 1125
 *
 * Returns 0 if current has write access, error code otherwise
 */
static int smack_file_lock(struct file *file, unsigned int cmd)
{
E
Etienne Basset 已提交
1126 1127
	struct smk_audit_info ad;

1128 1129
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
	smk_ad_setfield_u_fs_path(&ad, file->f_path);
E
Etienne Basset 已提交
1130
	return smk_curacc(file->f_security, MAY_WRITE, &ad);
1131 1132 1133 1134 1135 1136 1137 1138
}

/**
 * smack_file_fcntl - Smack check on fcntl
 * @file: the object
 * @cmd: what action to check
 * @arg: unused
 *
1139 1140 1141 1142
 * Generally these operations are harmless.
 * File locking operations present an obvious mechanism
 * for passing information, so they require write access.
 *
1143 1144 1145 1146 1147
 * Returns 0 if current has access, error code otherwise
 */
static int smack_file_fcntl(struct file *file, unsigned int cmd,
			    unsigned long arg)
{
E
Etienne Basset 已提交
1148
	struct smk_audit_info ad;
1149
	int rc = 0;
1150

E
Etienne Basset 已提交
1151

1152 1153 1154 1155 1156 1157
	switch (cmd) {
	case F_GETLK:
	case F_SETLK:
	case F_SETLKW:
	case F_SETOWN:
	case F_SETSIG:
1158 1159
		smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
		smk_ad_setfield_u_fs_path(&ad, file->f_path);
E
Etienne Basset 已提交
1160
		rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1161 1162
		break;
	default:
1163
		break;
1164 1165 1166 1167 1168
	}

	return rc;
}

1169
/**
1170
 * smack_mmap_file :
1171 1172 1173 1174 1175 1176 1177 1178
 * Check permissions for a mmap operation.  The @file may be NULL, e.g.
 * if mapping anonymous memory.
 * @file contains the file structure for file to map (may be NULL).
 * @reqprot contains the protection requested by the application.
 * @prot contains the protection that will be applied by the kernel.
 * @flags contains the operational flags.
 * Return 0 if permission is granted.
 */
1179
static int smack_mmap_file(struct file *file,
1180
			   unsigned long reqprot, unsigned long prot,
1181
			   unsigned long flags)
1182
{
1183
	struct smack_known *skp;
1184 1185 1186 1187
	struct smack_rule *srp;
	struct task_smack *tsp;
	char *sp;
	char *msmack;
1188
	char *osmack;
1189
	struct inode_smack *isp;
1190 1191 1192
	int may;
	int mmay;
	int tmay;
1193 1194
	int rc;

A
Al Viro 已提交
1195
	if (file == NULL)
1196 1197
		return 0;

A
Al Viro 已提交
1198
	isp = file_inode(file)->i_security;
1199 1200 1201 1202 1203 1204
	if (isp->smk_mmap == NULL)
		return 0;
	msmack = isp->smk_mmap;

	tsp = current_security();
	sp = smk_of_current();
1205
	skp = smk_find_entry(sp);
1206 1207 1208 1209 1210 1211 1212 1213
	rc = 0;

	rcu_read_lock();
	/*
	 * For each Smack rule associated with the subject
	 * label verify that the SMACK64MMAP also has access
	 * to that rule's object label.
	 */
1214
	list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
1215
		osmack = srp->smk_object;
1216 1217 1218
		/*
		 * Matching labels always allows access.
		 */
1219
		if (msmack == osmack)
1220
			continue;
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
		/*
		 * If there is a matching local rule take
		 * that into account as well.
		 */
		may = smk_access_entry(srp->smk_subject, osmack,
					&tsp->smk_rules);
		if (may == -ENOENT)
			may = srp->smk_access;
		else
			may &= srp->smk_access;
		/*
		 * If may is zero the SMACK64MMAP subject can't
		 * possibly have less access.
		 */
		if (may == 0)
			continue;

		/*
		 * Fetch the global list entry.
		 * If there isn't one a SMACK64MMAP subject
		 * can't have as much access as current.
		 */
1243 1244
		skp = smk_find_entry(msmack);
		mmay = smk_access_entry(msmack, osmack, &skp->smk_rules);
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
		if (mmay == -ENOENT) {
			rc = -EACCES;
			break;
		}
		/*
		 * If there is a local entry it modifies the
		 * potential access, too.
		 */
		tmay = smk_access_entry(msmack, osmack, &tsp->smk_rules);
		if (tmay != -ENOENT)
			mmay &= tmay;
1256

1257 1258 1259 1260 1261
		/*
		 * If there is any access available to current that is
		 * not available to a SMACK64MMAP subject
		 * deny access.
		 */
1262
		if ((may | mmay) != mmay) {
1263
			rc = -EACCES;
1264
			break;
1265
		}
1266 1267 1268 1269 1270 1271 1272
	}

	rcu_read_unlock();

	return rc;
}

1273 1274 1275 1276 1277 1278 1279 1280 1281
/**
 * smack_file_set_fowner - set the file security blob value
 * @file: object in question
 *
 * Returns 0
 * Further research may be required on this one.
 */
static int smack_file_set_fowner(struct file *file)
{
1282
	file->f_security = smk_of_current();
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
	return 0;
}

/**
 * smack_file_send_sigiotask - Smack on sigio
 * @tsk: The target task
 * @fown: the object the signal come from
 * @signum: unused
 *
 * Allow a privileged task to get signals even if it shouldn't
 *
 * Returns 0 if a subject with the object's smack could
 * write to the task, an error code otherwise.
 */
static int smack_file_send_sigiotask(struct task_struct *tsk,
				     struct fown_struct *fown, int signum)
{
	struct file *file;
	int rc;
1302
	char *tsp = smk_of_task(tsk->cred->security);
E
Etienne Basset 已提交
1303
	struct smk_audit_info ad;
1304 1305 1306 1307 1308

	/*
	 * struct fown_struct is never outside the context of a struct file
	 */
	file = container_of(fown, struct file, f_owner);
1309

E
Etienne Basset 已提交
1310 1311
	/* we don't log here as rc can be overriden */
	rc = smk_access(file->f_security, tsp, MAY_WRITE, NULL);
1312
	if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
E
Etienne Basset 已提交
1313 1314 1315 1316 1317
		rc = 0;

	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
	smk_ad_setfield_u_tsk(&ad, tsk);
	smack_log(file->f_security, tsp, MAY_WRITE, rc, &ad);
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
	return rc;
}

/**
 * smack_file_receive - Smack file receive check
 * @file: the object
 *
 * Returns 0 if current has access, error code otherwise
 */
static int smack_file_receive(struct file *file)
{
	int may = 0;
E
Etienne Basset 已提交
1330
	struct smk_audit_info ad;
1331

E
Etienne Basset 已提交
1332 1333
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
	smk_ad_setfield_u_fs_path(&ad, file->f_path);
1334 1335 1336 1337 1338 1339 1340 1341
	/*
	 * This code relies on bitmasks.
	 */
	if (file->f_mode & FMODE_READ)
		may = MAY_READ;
	if (file->f_mode & FMODE_WRITE)
		may |= MAY_WRITE;

E
Etienne Basset 已提交
1342
	return smk_curacc(file->f_security, may, &ad);
1343 1344
}

1345
/**
1346
 * smack_file_open - Smack dentry open processing
1347 1348 1349 1350 1351 1352 1353
 * @file: the object
 * @cred: unused
 *
 * Set the security blob in the file structure.
 *
 * Returns 0
 */
1354
static int smack_file_open(struct file *file, const struct cred *cred)
1355
{
A
Al Viro 已提交
1356
	struct inode_smack *isp = file_inode(file)->i_security;
1357 1358 1359 1360 1361 1362

	file->f_security = isp->smk_inode;

	return 0;
}

1363 1364 1365 1366
/*
 * Task hooks
 */

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
/**
 * smack_cred_alloc_blank - "allocate" blank task-level security credentials
 * @new: the new credentials
 * @gfp: the atomicity of any memory allocations
 *
 * Prepare a blank set of credentials for modification.  This must allocate all
 * the memory the LSM module might require such that cred_transfer() can
 * complete without error.
 */
static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp)
{
1378 1379 1380 1381
	struct task_smack *tsp;

	tsp = new_task_smack(NULL, NULL, gfp);
	if (tsp == NULL)
1382
		return -ENOMEM;
1383 1384 1385

	cred->security = tsp;

1386 1387 1388 1389
	return 0;
}


1390
/**
1391 1392
 * smack_cred_free - "free" task-level security credentials
 * @cred: the credentials in question
1393 1394
 *
 */
1395
static void smack_cred_free(struct cred *cred)
1396
{
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
	struct task_smack *tsp = cred->security;
	struct smack_rule *rp;
	struct list_head *l;
	struct list_head *n;

	if (tsp == NULL)
		return;
	cred->security = NULL;

	list_for_each_safe(l, n, &tsp->smk_rules) {
		rp = list_entry(l, struct smack_rule, list);
		list_del(&rp->list);
		kfree(rp);
	}
	kfree(tsp);
1412 1413
}

D
David Howells 已提交
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
/**
 * smack_cred_prepare - prepare new set of credentials for modification
 * @new: the new credentials
 * @old: the original credentials
 * @gfp: the atomicity of any memory allocations
 *
 * Prepare a new set of credentials for modification.
 */
static int smack_cred_prepare(struct cred *new, const struct cred *old,
			      gfp_t gfp)
{
1425 1426
	struct task_smack *old_tsp = old->security;
	struct task_smack *new_tsp;
1427
	int rc;
1428

1429
	new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp);
1430 1431 1432
	if (new_tsp == NULL)
		return -ENOMEM;

1433 1434 1435 1436
	rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp);
	if (rc != 0)
		return rc;

1437
	new->security = new_tsp;
D
David Howells 已提交
1438 1439 1440
	return 0;
}

1441 1442 1443 1444 1445 1446 1447 1448 1449
/**
 * smack_cred_transfer - Transfer the old credentials to the new credentials
 * @new: the new credentials
 * @old: the original credentials
 *
 * Fill in a set of blank credentials from another set of credentials.
 */
static void smack_cred_transfer(struct cred *new, const struct cred *old)
{
1450 1451 1452 1453 1454
	struct task_smack *old_tsp = old->security;
	struct task_smack *new_tsp = new->security;

	new_tsp->smk_task = old_tsp->smk_task;
	new_tsp->smk_forked = old_tsp->smk_task;
1455 1456 1457 1458 1459
	mutex_init(&new_tsp->smk_rules_lock);
	INIT_LIST_HEAD(&new_tsp->smk_rules);


	/* cbs copy rule list */
1460 1461
}

1462 1463
/**
 * smack_kernel_act_as - Set the subjective context in a set of credentials
1464 1465
 * @new: points to the set of credentials to be modified.
 * @secid: specifies the security ID to be set
1466 1467 1468 1469 1470
 *
 * Set the security data for a kernel service.
 */
static int smack_kernel_act_as(struct cred *new, u32 secid)
{
1471
	struct task_smack *new_tsp = new->security;
1472 1473 1474 1475 1476
	char *smack = smack_from_secid(secid);

	if (smack == NULL)
		return -EINVAL;

1477
	new_tsp->smk_task = smack;
1478 1479 1480 1481 1482
	return 0;
}

/**
 * smack_kernel_create_files_as - Set the file creation label in a set of creds
1483 1484
 * @new: points to the set of credentials to be modified
 * @inode: points to the inode to use as a reference
1485 1486 1487 1488 1489 1490 1491 1492
 *
 * Set the file creation context in a set of credentials to the same
 * as the objective context of the specified inode
 */
static int smack_kernel_create_files_as(struct cred *new,
					struct inode *inode)
{
	struct inode_smack *isp = inode->i_security;
1493
	struct task_smack *tsp = new->security;
1494

1495 1496
	tsp->smk_forked = isp->smk_inode;
	tsp->smk_task = isp->smk_inode;
1497 1498 1499
	return 0;
}

E
Etienne Basset 已提交
1500 1501 1502
/**
 * smk_curacc_on_task - helper to log task related access
 * @p: the task object
1503 1504
 * @access: the access requested
 * @caller: name of the calling function for audit
E
Etienne Basset 已提交
1505 1506 1507
 *
 * Return 0 if access is permitted
 */
1508 1509
static int smk_curacc_on_task(struct task_struct *p, int access,
				const char *caller)
E
Etienne Basset 已提交
1510 1511 1512
{
	struct smk_audit_info ad;

1513
	smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
E
Etienne Basset 已提交
1514
	smk_ad_setfield_u_tsk(&ad, p);
1515
	return smk_curacc(smk_of_task(task_security(p)), access, &ad);
E
Etienne Basset 已提交
1516 1517
}

1518 1519 1520 1521 1522 1523 1524 1525 1526
/**
 * smack_task_setpgid - Smack check on setting pgid
 * @p: the task object
 * @pgid: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
{
1527
	return smk_curacc_on_task(p, MAY_WRITE, __func__);
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
}

/**
 * smack_task_getpgid - Smack access check for getpgid
 * @p: the object task
 *
 * Returns 0 if current can read the object task, error code otherwise
 */
static int smack_task_getpgid(struct task_struct *p)
{
1538
	return smk_curacc_on_task(p, MAY_READ, __func__);
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
}

/**
 * smack_task_getsid - Smack access check for getsid
 * @p: the object task
 *
 * Returns 0 if current can read the object task, error code otherwise
 */
static int smack_task_getsid(struct task_struct *p)
{
1549
	return smk_curacc_on_task(p, MAY_READ, __func__);
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
}

/**
 * smack_task_getsecid - get the secid of the task
 * @p: the object task
 * @secid: where to put the result
 *
 * Sets the secid to contain a u32 version of the smack label.
 */
static void smack_task_getsecid(struct task_struct *p, u32 *secid)
{
1561
	*secid = smack_to_secid(smk_of_task(task_security(p)));
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
}

/**
 * smack_task_setnice - Smack check on setting nice
 * @p: the task object
 * @nice: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setnice(struct task_struct *p, int nice)
{
1573 1574 1575 1576
	int rc;

	rc = cap_task_setnice(p, nice);
	if (rc == 0)
1577
		rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1578
	return rc;
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
}

/**
 * smack_task_setioprio - Smack check on setting ioprio
 * @p: the task object
 * @ioprio: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setioprio(struct task_struct *p, int ioprio)
{
1590 1591 1592 1593
	int rc;

	rc = cap_task_setioprio(p, ioprio);
	if (rc == 0)
1594
		rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1595
	return rc;
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
}

/**
 * smack_task_getioprio - Smack check on reading ioprio
 * @p: the task object
 *
 * Return 0 if read access is permitted
 */
static int smack_task_getioprio(struct task_struct *p)
{
1606
	return smk_curacc_on_task(p, MAY_READ, __func__);
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
}

/**
 * smack_task_setscheduler - Smack check on setting scheduler
 * @p: the task object
 * @policy: unused
 * @lp: unused
 *
 * Return 0 if read access is permitted
 */
1617
static int smack_task_setscheduler(struct task_struct *p)
1618
{
1619 1620
	int rc;

1621
	rc = cap_task_setscheduler(p);
1622
	if (rc == 0)
1623
		rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1624
	return rc;
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
}

/**
 * smack_task_getscheduler - Smack check on reading scheduler
 * @p: the task object
 *
 * Return 0 if read access is permitted
 */
static int smack_task_getscheduler(struct task_struct *p)
{
1635
	return smk_curacc_on_task(p, MAY_READ, __func__);
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
}

/**
 * smack_task_movememory - Smack check on moving memory
 * @p: the task object
 *
 * Return 0 if write access is permitted
 */
static int smack_task_movememory(struct task_struct *p)
{
1646
	return smk_curacc_on_task(p, MAY_WRITE, __func__);
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
}

/**
 * smack_task_kill - Smack check on signal delivery
 * @p: the task object
 * @info: unused
 * @sig: unused
 * @secid: identifies the smack to use in lieu of current's
 *
 * Return 0 if write access is permitted
 *
 * The secid behavior is an artifact of an SELinux hack
 * in the USB code. Someday it may go away.
 */
static int smack_task_kill(struct task_struct *p, struct siginfo *info,
			   int sig, u32 secid)
{
E
Etienne Basset 已提交
1664 1665 1666 1667
	struct smk_audit_info ad;

	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
	smk_ad_setfield_u_tsk(&ad, p);
1668 1669 1670 1671 1672
	/*
	 * Sending a signal requires that the sender
	 * can write the receiver.
	 */
	if (secid == 0)
1673 1674
		return smk_curacc(smk_of_task(task_security(p)), MAY_WRITE,
				  &ad);
1675 1676 1677 1678 1679
	/*
	 * If the secid isn't 0 we're dealing with some USB IO
	 * specific behavior. This is not clean. For one thing
	 * we can't take privilege into account.
	 */
1680 1681
	return smk_access(smack_from_secid(secid),
			  smk_of_task(task_security(p)), MAY_WRITE, &ad);
1682 1683 1684 1685 1686 1687
}

/**
 * smack_task_wait - Smack access check for waiting
 * @p: task to wait for
 *
1688
 * Returns 0
1689 1690 1691 1692
 */
static int smack_task_wait(struct task_struct *p)
{
	/*
1693 1694 1695 1696 1697 1698
	 * Allow the operation to succeed.
	 * Zombies are bad.
	 * In userless environments (e.g. phones) programs
	 * get marked with SMACK64EXEC and even if the parent
	 * and child shouldn't be talking the parent still
	 * may expect to know when the child exits.
1699
	 */
1700
	return 0;
1701 1702 1703 1704 1705
}

/**
 * smack_task_to_inode - copy task smack into the inode blob
 * @p: task to copy from
1706
 * @inode: inode to copy to
1707 1708 1709 1710 1711 1712
 *
 * Sets the smack pointer in the inode security blob
 */
static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
{
	struct inode_smack *isp = inode->i_security;
1713
	isp->smk_inode = smk_of_task(task_security(p));
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
}

/*
 * Socket hooks.
 */

/**
 * smack_sk_alloc_security - Allocate a socket blob
 * @sk: the socket
 * @family: unused
1724
 * @gfp_flags: memory allocation flags
1725 1726 1727 1728 1729 1730 1731
 *
 * Assign Smack pointers to current
 *
 * Returns 0 on success, -ENOMEM is there's no memory
 */
static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
{
1732
	char *csp = smk_of_current();
1733 1734 1735 1736 1737 1738 1739 1740
	struct socket_smack *ssp;

	ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
	if (ssp == NULL)
		return -ENOMEM;

	ssp->smk_in = csp;
	ssp->smk_out = csp;
1741
	ssp->smk_packet = NULL;
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758

	sk->sk_security = ssp;

	return 0;
}

/**
 * smack_sk_free_security - Free a socket blob
 * @sk: the socket
 *
 * Clears the blob pointer
 */
static void smack_sk_free_security(struct sock *sk)
{
	kfree(sk->sk_security);
}

1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
/**
* smack_host_label - check host based restrictions
* @sip: the object end
*
* looks for host based access restrictions
*
* This version will only be appropriate for really small sets of single label
* hosts.  The caller is responsible for ensuring that the RCU read lock is
* taken before calling this function.
*
* Returns the label of the far end or NULL if it's not special.
*/
static char *smack_host_label(struct sockaddr_in *sip)
{
	struct smk_netlbladdr *snp;
	struct in_addr *siap = &sip->sin_addr;

	if (siap->s_addr == 0)
		return NULL;

	list_for_each_entry_rcu(snp, &smk_netlbladdr_list, list)
		/*
		* we break after finding the first match because
		* the list is sorted from longest to shortest mask
		* so we have found the most specific match
		*/
		if ((&snp->smk_host.sin_addr)->s_addr ==
1786 1787 1788 1789
		    (siap->s_addr & (&snp->smk_mask)->s_addr)) {
			/* we have found the special CIPSO option */
			if (snp->smk_label == smack_cipso_option)
				return NULL;
1790
			return snp->smk_label;
1791
		}
1792 1793 1794 1795

	return NULL;
}

1796 1797 1798
/**
 * smack_netlabel - Set the secattr on a socket
 * @sk: the socket
1799
 * @labeled: socket label scheme
1800 1801 1802 1803 1804 1805
 *
 * Convert the outbound smack value (smk_out) to a
 * secattr and attach it to the socket.
 *
 * Returns 0 on success or an error code
 */
1806
static int smack_netlabel(struct sock *sk, int labeled)
1807
{
1808
	struct smack_known *skp;
1809
	struct socket_smack *ssp = sk->sk_security;
1810
	int rc = 0;
1811

1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
	/*
	 * Usually the netlabel code will handle changing the
	 * packet labeling based on the label.
	 * The case of a single label host is different, because
	 * a single label host should never get a labeled packet
	 * even though the label is usually associated with a packet
	 * label.
	 */
	local_bh_disable();
	bh_lock_sock_nested(sk);

	if (ssp->smk_out == smack_net_ambient ||
	    labeled == SMACK_UNLABELED_SOCKET)
		netlbl_sock_delattr(sk);
	else {
1827 1828
		skp = smk_find_entry(ssp->smk_out);
		rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel);
1829 1830 1831 1832
	}

	bh_unlock_sock(sk);
	local_bh_enable();
1833

1834 1835 1836
	return rc;
}

1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853
/**
 * smack_netlbel_send - Set the secattr on a socket and perform access checks
 * @sk: the socket
 * @sap: the destination address
 *
 * Set the correct secattr for the given socket based on the destination
 * address and perform any outbound access checks needed.
 *
 * Returns 0 on success or an error code.
 *
 */
static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
{
	int rc;
	int sk_lbl;
	char *hostsp;
	struct socket_smack *ssp = sk->sk_security;
E
Etienne Basset 已提交
1854
	struct smk_audit_info ad;
1855 1856 1857 1858

	rcu_read_lock();
	hostsp = smack_host_label(sap);
	if (hostsp != NULL) {
E
Etienne Basset 已提交
1859
#ifdef CONFIG_AUDIT
1860 1861
		struct lsm_network_audit net;

1862 1863 1864 1865
		smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
		ad.a.u.net->family = sap->sin_family;
		ad.a.u.net->dport = sap->sin_port;
		ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr;
E
Etienne Basset 已提交
1866
#endif
1867
		sk_lbl = SMACK_UNLABELED_SOCKET;
E
Etienne Basset 已提交
1868
		rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE, &ad);
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
	} else {
		sk_lbl = SMACK_CIPSO_SOCKET;
		rc = 0;
	}
	rcu_read_unlock();
	if (rc != 0)
		return rc;

	return smack_netlabel(sk, sk_lbl);
}

1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
/**
 * smack_inode_setsecurity - set smack xattrs
 * @inode: the object
 * @name: attribute name
 * @value: attribute value
 * @size: size of the attribute
 * @flags: unused
 *
 * Sets the named attribute in the appropriate blob
 *
 * Returns 0 on success, or an error code
 */
static int smack_inode_setsecurity(struct inode *inode, const char *name,
				   const void *value, size_t size, int flags)
{
	char *sp;
	struct inode_smack *nsp = inode->i_security;
	struct socket_smack *ssp;
	struct socket *sock;
1899
	int rc = 0;
1900

1901
	if (value == NULL || size > SMK_LONGLABEL || size == 0)
1902 1903 1904 1905 1906 1907 1908 1909
		return -EACCES;

	sp = smk_import(value, size);
	if (sp == NULL)
		return -EINVAL;

	if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
		nsp->smk_inode = sp;
1910
		nsp->smk_flags |= SMK_INODE_INSTANT;
1911 1912 1913 1914 1915 1916 1917 1918 1919
		return 0;
	}
	/*
	 * The rest of the Smack xattrs are only on sockets.
	 */
	if (inode->i_sb->s_magic != SOCKFS_MAGIC)
		return -EOPNOTSUPP;

	sock = SOCKET_I(inode);
1920
	if (sock == NULL || sock->sk == NULL)
1921 1922 1923 1924 1925 1926 1927 1928
		return -EOPNOTSUPP;

	ssp = sock->sk->sk_security;

	if (strcmp(name, XATTR_SMACK_IPIN) == 0)
		ssp->smk_in = sp;
	else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
		ssp->smk_out = sp;
C
Casey Schaufler 已提交
1929 1930 1931 1932 1933 1934 1935
		if (sock->sk->sk_family != PF_UNIX) {
			rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
			if (rc != 0)
				printk(KERN_WARNING
					"Smack: \"%s\" netlbl error %d.\n",
					__func__, -rc);
		}
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
	} else
		return -EOPNOTSUPP;

	return 0;
}

/**
 * smack_socket_post_create - finish socket setup
 * @sock: the socket
 * @family: protocol family
 * @type: unused
 * @protocol: unused
 * @kern: unused
 *
 * Sets the netlabel information on the socket
 *
 * Returns 0 on success, and error code otherwise
 */
static int smack_socket_post_create(struct socket *sock, int family,
				    int type, int protocol, int kern)
{
1957
	if (family != PF_INET || sock->sk == NULL)
1958 1959 1960 1961
		return 0;
	/*
	 * Set the outbound netlbl.
	 */
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
	return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
}

/**
 * smack_socket_connect - connect access check
 * @sock: the socket
 * @sap: the other end
 * @addrlen: size of sap
 *
 * Verifies that a connection may be possible
 *
 * Returns 0 on success, and error code otherwise
 */
static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
				int addrlen)
{
	if (sock->sk == NULL || sock->sk->sk_family != PF_INET)
		return 0;
	if (addrlen < sizeof(struct sockaddr_in))
		return -EINVAL;

1983
	return smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
}

/**
 * smack_flags_to_may - convert S_ to MAY_ values
 * @flags: the S_ value
 *
 * Returns the equivalent MAY_ value
 */
static int smack_flags_to_may(int flags)
{
	int may = 0;

	if (flags & S_IRUGO)
		may |= MAY_READ;
	if (flags & S_IWUGO)
		may |= MAY_WRITE;
	if (flags & S_IXUGO)
		may |= MAY_EXEC;

	return may;
}

/**
 * smack_msg_msg_alloc_security - Set the security blob for msg_msg
 * @msg: the object
 *
 * Returns 0
 */
static int smack_msg_msg_alloc_security(struct msg_msg *msg)
{
2014
	msg->security = smk_of_current();
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
	return 0;
}

/**
 * smack_msg_msg_free_security - Clear the security blob for msg_msg
 * @msg: the object
 *
 * Clears the blob pointer
 */
static void smack_msg_msg_free_security(struct msg_msg *msg)
{
	msg->security = NULL;
}

/**
 * smack_of_shm - the smack pointer for the shm
 * @shp: the object
 *
 * Returns a pointer to the smack value
 */
static char *smack_of_shm(struct shmid_kernel *shp)
{
	return (char *)shp->shm_perm.security;
}

/**
 * smack_shm_alloc_security - Set the security blob for shm
 * @shp: the object
 *
 * Returns 0
 */
static int smack_shm_alloc_security(struct shmid_kernel *shp)
{
	struct kern_ipc_perm *isp = &shp->shm_perm;

2050
	isp->security = smk_of_current();
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
	return 0;
}

/**
 * smack_shm_free_security - Clear the security blob for shm
 * @shp: the object
 *
 * Clears the blob pointer
 */
static void smack_shm_free_security(struct shmid_kernel *shp)
{
	struct kern_ipc_perm *isp = &shp->shm_perm;

	isp->security = NULL;
}

E
Etienne Basset 已提交
2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
/**
 * smk_curacc_shm : check if current has access on shm
 * @shp : the object
 * @access : access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smk_curacc_shm(struct shmid_kernel *shp, int access)
{
	char *ssp = smack_of_shm(shp);
	struct smk_audit_info ad;

#ifdef CONFIG_AUDIT
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
	ad.a.u.ipc_id = shp->shm_perm.id;
#endif
	return smk_curacc(ssp, access, &ad);
}

2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
/**
 * smack_shm_associate - Smack access check for shm
 * @shp: the object
 * @shmflg: access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
{
	int may;

	may = smack_flags_to_may(shmflg);
E
Etienne Basset 已提交
2098
	return smk_curacc_shm(shp, may);
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
}

/**
 * smack_shm_shmctl - Smack access check for shm
 * @shp: the object
 * @cmd: what it wants to do
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
{
	int may;

	switch (cmd) {
	case IPC_STAT:
	case SHM_STAT:
		may = MAY_READ;
		break;
	case IPC_SET:
	case SHM_LOCK:
	case SHM_UNLOCK:
	case IPC_RMID:
		may = MAY_READWRITE;
		break;
	case IPC_INFO:
	case SHM_INFO:
		/*
		 * System level information.
		 */
		return 0;
	default:
		return -EINVAL;
	}
E
Etienne Basset 已提交
2132
	return smk_curacc_shm(shp, may);
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
}

/**
 * smack_shm_shmat - Smack access for shmat
 * @shp: the object
 * @shmaddr: unused
 * @shmflg: access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
			   int shmflg)
{
	int may;

	may = smack_flags_to_may(shmflg);
E
Etienne Basset 已提交
2149
	return smk_curacc_shm(shp, may);
2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
}

/**
 * smack_of_sem - the smack pointer for the sem
 * @sma: the object
 *
 * Returns a pointer to the smack value
 */
static char *smack_of_sem(struct sem_array *sma)
{
	return (char *)sma->sem_perm.security;
}

/**
 * smack_sem_alloc_security - Set the security blob for sem
 * @sma: the object
 *
 * Returns 0
 */
static int smack_sem_alloc_security(struct sem_array *sma)
{
	struct kern_ipc_perm *isp = &sma->sem_perm;

2173
	isp->security = smk_of_current();
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189
	return 0;
}

/**
 * smack_sem_free_security - Clear the security blob for sem
 * @sma: the object
 *
 * Clears the blob pointer
 */
static void smack_sem_free_security(struct sem_array *sma)
{
	struct kern_ipc_perm *isp = &sma->sem_perm;

	isp->security = NULL;
}

E
Etienne Basset 已提交
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
/**
 * smk_curacc_sem : check if current has access on sem
 * @sma : the object
 * @access : access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smk_curacc_sem(struct sem_array *sma, int access)
{
	char *ssp = smack_of_sem(sma);
	struct smk_audit_info ad;

#ifdef CONFIG_AUDIT
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
	ad.a.u.ipc_id = sma->sem_perm.id;
#endif
	return smk_curacc(ssp, access, &ad);
}

2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220
/**
 * smack_sem_associate - Smack access check for sem
 * @sma: the object
 * @semflg: access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_sem_associate(struct sem_array *sma, int semflg)
{
	int may;

	may = smack_flags_to_may(semflg);
E
Etienne Basset 已提交
2221
	return smk_curacc_sem(sma, may);
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
}

/**
 * smack_sem_shmctl - Smack access check for sem
 * @sma: the object
 * @cmd: what it wants to do
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_sem_semctl(struct sem_array *sma, int cmd)
{
	int may;

	switch (cmd) {
	case GETPID:
	case GETNCNT:
	case GETZCNT:
	case GETVAL:
	case GETALL:
	case IPC_STAT:
	case SEM_STAT:
		may = MAY_READ;
		break;
	case SETVAL:
	case SETALL:
	case IPC_RMID:
	case IPC_SET:
		may = MAY_READWRITE;
		break;
	case IPC_INFO:
	case SEM_INFO:
		/*
		 * System level information
		 */
		return 0;
	default:
		return -EINVAL;
	}

E
Etienne Basset 已提交
2261
	return smk_curacc_sem(sma, may);
2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
}

/**
 * smack_sem_semop - Smack checks of semaphore operations
 * @sma: the object
 * @sops: unused
 * @nsops: unused
 * @alter: unused
 *
 * Treated as read and write in all cases.
 *
 * Returns 0 if access is allowed, error code otherwise
 */
static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
			   unsigned nsops, int alter)
{
E
Etienne Basset 已提交
2278
	return smk_curacc_sem(sma, MAY_READWRITE);
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
}

/**
 * smack_msg_alloc_security - Set the security blob for msg
 * @msq: the object
 *
 * Returns 0
 */
static int smack_msg_queue_alloc_security(struct msg_queue *msq)
{
	struct kern_ipc_perm *kisp = &msq->q_perm;

2291
	kisp->security = smk_of_current();
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
	return 0;
}

/**
 * smack_msg_free_security - Clear the security blob for msg
 * @msq: the object
 *
 * Clears the blob pointer
 */
static void smack_msg_queue_free_security(struct msg_queue *msq)
{
	struct kern_ipc_perm *kisp = &msq->q_perm;

	kisp->security = NULL;
}

/**
 * smack_of_msq - the smack pointer for the msq
 * @msq: the object
 *
 * Returns a pointer to the smack value
 */
static char *smack_of_msq(struct msg_queue *msq)
{
	return (char *)msq->q_perm.security;
}

E
Etienne Basset 已提交
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337
/**
 * smk_curacc_msq : helper to check if current has access on msq
 * @msq : the msq
 * @access : access requested
 *
 * return 0 if current has access, error otherwise
 */
static int smk_curacc_msq(struct msg_queue *msq, int access)
{
	char *msp = smack_of_msq(msq);
	struct smk_audit_info ad;

#ifdef CONFIG_AUDIT
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
	ad.a.u.ipc_id = msq->q_perm.id;
#endif
	return smk_curacc(msp, access, &ad);
}

2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
/**
 * smack_msg_queue_associate - Smack access check for msg_queue
 * @msq: the object
 * @msqflg: access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
{
	int may;

	may = smack_flags_to_may(msqflg);
E
Etienne Basset 已提交
2350
	return smk_curacc_msq(msq, may);
2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
}

/**
 * smack_msg_queue_msgctl - Smack access check for msg_queue
 * @msq: the object
 * @cmd: what it wants to do
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
{
	int may;

	switch (cmd) {
	case IPC_STAT:
	case MSG_STAT:
		may = MAY_READ;
		break;
	case IPC_SET:
	case IPC_RMID:
		may = MAY_READWRITE;
		break;
	case IPC_INFO:
	case MSG_INFO:
		/*
		 * System level information
		 */
		return 0;
	default:
		return -EINVAL;
	}

E
Etienne Basset 已提交
2383
	return smk_curacc_msq(msq, may);
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
}

/**
 * smack_msg_queue_msgsnd - Smack access check for msg_queue
 * @msq: the object
 * @msg: unused
 * @msqflg: access requested
 *
 * Returns 0 if current has the requested access, error code otherwise
 */
static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
				  int msqflg)
{
E
Etienne Basset 已提交
2397
	int may;
2398

E
Etienne Basset 已提交
2399 2400
	may = smack_flags_to_may(msqflg);
	return smk_curacc_msq(msq, may);
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
}

/**
 * smack_msg_queue_msgsnd - Smack access check for msg_queue
 * @msq: the object
 * @msg: unused
 * @target: unused
 * @type: unused
 * @mode: unused
 *
 * Returns 0 if current has read and write access, error code otherwise
 */
static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
			struct task_struct *target, long type, int mode)
{
E
Etienne Basset 已提交
2416
	return smk_curacc_msq(msq, MAY_READWRITE);
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
}

/**
 * smack_ipc_permission - Smack access for ipc_permission()
 * @ipp: the object permissions
 * @flag: access requested
 *
 * Returns 0 if current has read and write access, error code otherwise
 */
static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
{
	char *isp = ipp->security;
E
Etienne Basset 已提交
2429 2430
	int may = smack_flags_to_may(flag);
	struct smk_audit_info ad;
2431

E
Etienne Basset 已提交
2432 2433 2434 2435 2436
#ifdef CONFIG_AUDIT
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
	ad.a.u.ipc_id = ipp->id;
#endif
	return smk_curacc(isp, may, &ad);
2437 2438
}

2439 2440
/**
 * smack_ipc_getsecid - Extract smack security id
2441
 * @ipp: the object permissions
2442 2443 2444 2445 2446 2447 2448 2449 2450
 * @secid: where result will be saved
 */
static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
{
	char *smack = ipp->security;

	*secid = smack_to_secid(smack);
}

2451 2452
/**
 * smack_d_instantiate - Make sure the blob is correct on an inode
2453
 * @opt_dentry: dentry where inode will be attached
2454 2455 2456 2457 2458 2459 2460 2461 2462
 * @inode: the object
 *
 * Set the inode's security blob if it hasn't been done already.
 */
static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
{
	struct super_block *sbp;
	struct superblock_smack *sbsp;
	struct inode_smack *isp;
2463
	char *csp = smk_of_current();
2464 2465
	char *fetched;
	char *final;
2466 2467
	char trattr[TRANS_TRUE_SIZE];
	int transflag = 0;
C
Casey Schaufler 已提交
2468
	int rc;
2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491
	struct dentry *dp;

	if (inode == NULL)
		return;

	isp = inode->i_security;

	mutex_lock(&isp->smk_lock);
	/*
	 * If the inode is already instantiated
	 * take the quick way out
	 */
	if (isp->smk_flags & SMK_INODE_INSTANT)
		goto unlockandout;

	sbp = inode->i_sb;
	sbsp = sbp->s_security;
	/*
	 * We're going to use the superblock default label
	 * if there's no label on the file.
	 */
	final = sbsp->smk_default;

C
Casey Schaufler 已提交
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
	/*
	 * If this is the root inode the superblock
	 * may be in the process of initialization.
	 * If that is the case use the root value out
	 * of the superblock.
	 */
	if (opt_dentry->d_parent == opt_dentry) {
		isp->smk_inode = sbsp->smk_root;
		isp->smk_flags |= SMK_INODE_INSTANT;
		goto unlockandout;
	}

2504 2505 2506 2507 2508 2509 2510 2511 2512
	/*
	 * This is pretty hackish.
	 * Casey says that we shouldn't have to do
	 * file system specific code, but it does help
	 * with keeping it simple.
	 */
	switch (sbp->s_magic) {
	case SMACK_MAGIC:
		/*
L
Lucas De Marchi 已提交
2513
		 * Casey says that it's a little embarrassing
2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534
		 * that the smack file system doesn't do
		 * extended attributes.
		 */
		final = smack_known_star.smk_known;
		break;
	case PIPEFS_MAGIC:
		/*
		 * Casey says pipes are easy (?)
		 */
		final = smack_known_star.smk_known;
		break;
	case DEVPTS_SUPER_MAGIC:
		/*
		 * devpts seems content with the label of the task.
		 * Programs that change smack have to treat the
		 * pty with respect.
		 */
		final = csp;
		break;
	case SOCKFS_MAGIC:
		/*
C
Casey Schaufler 已提交
2535 2536
		 * Socket access is controlled by the socket
		 * structures associated with the task involved.
2537
		 */
C
Casey Schaufler 已提交
2538
		final = smack_known_star.smk_known;
2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564
		break;
	case PROC_SUPER_MAGIC:
		/*
		 * Casey says procfs appears not to care.
		 * The superblock default suffices.
		 */
		break;
	case TMPFS_MAGIC:
		/*
		 * Device labels should come from the filesystem,
		 * but watch out, because they're volitile,
		 * getting recreated on every reboot.
		 */
		final = smack_known_star.smk_known;
		/*
		 * No break.
		 *
		 * If a smack value has been set we want to use it,
		 * but since tmpfs isn't giving us the opportunity
		 * to set mount options simulate setting the
		 * superblock default.
		 */
	default:
		/*
		 * This isn't an understood special case.
		 * Get the value from the xattr.
C
Casey Schaufler 已提交
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
		 */

		/*
		 * UNIX domain sockets use lower level socket data.
		 */
		if (S_ISSOCK(inode->i_mode)) {
			final = smack_known_star.smk_known;
			break;
		}
		/*
2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
		 * No xattr support means, alas, no SMACK label.
		 * Use the aforeapplied default.
		 * It would be curious if the label of the task
		 * does not match that assigned.
		 */
		if (inode->i_op->getxattr == NULL)
			break;
		/*
		 * Get the dentry for xattr.
		 */
2585
		dp = dget(opt_dentry);
2586
		fetched = smk_fetch(XATTR_NAME_SMACK, inode, dp);
C
Casey Schaufler 已提交
2587
		if (fetched != NULL)
2588
			final = fetched;
C
Casey Schaufler 已提交
2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605

		/*
		 * Transmuting directory
		 */
		if (S_ISDIR(inode->i_mode)) {
			/*
			 * If this is a new directory and the label was
			 * transmuted when the inode was initialized
			 * set the transmute attribute on the directory
			 * and mark the inode.
			 *
			 * If there is a transmute attribute on the
			 * directory mark the inode.
			 */
			if (isp->smk_flags & SMK_INODE_CHANGED) {
				isp->smk_flags &= ~SMK_INODE_CHANGED;
				rc = inode->i_op->setxattr(dp,
2606
					XATTR_NAME_SMACKTRANSMUTE,
C
Casey Schaufler 已提交
2607 2608 2609 2610 2611 2612 2613 2614 2615
					TRANS_TRUE, TRANS_TRUE_SIZE,
					0);
			} else {
				rc = inode->i_op->getxattr(dp,
					XATTR_NAME_SMACKTRANSMUTE, trattr,
					TRANS_TRUE_SIZE);
				if (rc >= 0 && strncmp(trattr, TRANS_TRUE,
						       TRANS_TRUE_SIZE) != 0)
					rc = -EINVAL;
2616
			}
C
Casey Schaufler 已提交
2617 2618
			if (rc >= 0)
				transflag = SMK_INODE_TRANSMUTE;
2619 2620
		}
		isp->smk_task = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
2621
		isp->smk_mmap = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
2622

2623 2624 2625 2626 2627 2628 2629 2630 2631
		dput(dp);
		break;
	}

	if (final == NULL)
		isp->smk_inode = csp;
	else
		isp->smk_inode = final;

2632
	isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656

unlockandout:
	mutex_unlock(&isp->smk_lock);
	return;
}

/**
 * smack_getprocattr - Smack process attribute access
 * @p: the object task
 * @name: the name of the attribute in /proc/.../attr
 * @value: where to put the result
 *
 * Places a copy of the task Smack into value
 *
 * Returns the length of the smack label or an error code
 */
static int smack_getprocattr(struct task_struct *p, char *name, char **value)
{
	char *cp;
	int slen;

	if (strcmp(name, "current") != 0)
		return -EINVAL;

2657
	cp = kstrdup(smk_of_task(task_security(p)), GFP_KERNEL);
2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
	if (cp == NULL)
		return -ENOMEM;

	slen = strlen(cp);
	*value = cp;
	return slen;
}

/**
 * smack_setprocattr - Smack process attribute setting
 * @p: the object task
 * @name: the name of the attribute in /proc/.../attr
 * @value: the value to set
 * @size: the size of the value
 *
 * Sets the Smack value of the task. Only setting self
 * is permitted and only with privilege
 *
 * Returns the length of the smack label or an error code
 */
static int smack_setprocattr(struct task_struct *p, char *name,
			     void *value, size_t size)
{
2681
	struct task_smack *tsp;
D
David Howells 已提交
2682
	struct cred *new;
2683 2684 2685 2686 2687 2688 2689 2690 2691
	char *newsmack;

	/*
	 * Changing another process' Smack value is too dangerous
	 * and supports no sane use case.
	 */
	if (p != current)
		return -EPERM;

2692
	if (!smack_privileged(CAP_MAC_ADMIN))
2693 2694
		return -EPERM;

2695
	if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
2696 2697 2698 2699 2700 2701 2702 2703 2704
		return -EINVAL;

	if (strcmp(name, "current") != 0)
		return -EINVAL;

	newsmack = smk_import(value, size);
	if (newsmack == NULL)
		return -EINVAL;

2705 2706 2707 2708 2709 2710
	/*
	 * No process is ever allowed the web ("@") label.
	 */
	if (newsmack == smack_known_web.smk_known)
		return -EPERM;

D
David Howells 已提交
2711
	new = prepare_creds();
2712
	if (new == NULL)
D
David Howells 已提交
2713
		return -ENOMEM;
2714

2715 2716
	tsp = new->security;
	tsp->smk_task = newsmack;
2717

D
David Howells 已提交
2718
	commit_creds(new);
2719 2720 2721 2722 2723
	return size;
}

/**
 * smack_unix_stream_connect - Smack access on UDS
2724 2725
 * @sock: one sock
 * @other: the other sock
2726 2727 2728 2729 2730
 * @newsk: unused
 *
 * Return 0 if a subject with the smack of sock could access
 * an object with the smack of other, otherwise an error code
 */
2731 2732
static int smack_unix_stream_connect(struct sock *sock,
				     struct sock *other, struct sock *newsk)
2733
{
J
James Morris 已提交
2734 2735
	struct socket_smack *ssp = sock->sk_security;
	struct socket_smack *osp = other->sk_security;
2736
	struct socket_smack *nsp = newsk->sk_security;
E
Etienne Basset 已提交
2737
	struct smk_audit_info ad;
C
Casey Schaufler 已提交
2738
	int rc = 0;
2739

2740 2741 2742
#ifdef CONFIG_AUDIT
	struct lsm_network_audit net;

2743
	smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2744
	smk_ad_setfield_u_net_sk(&ad, other);
2745
#endif
C
Casey Schaufler 已提交
2746

2747
	if (!smack_privileged(CAP_MAC_OVERRIDE))
C
Casey Schaufler 已提交
2748 2749
		rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);

2750 2751 2752 2753 2754 2755 2756 2757
	/*
	 * Cross reference the peer labels for SO_PEERSEC.
	 */
	if (rc == 0) {
		nsp->smk_packet = ssp->smk_out;
		ssp->smk_packet = osp->smk_out;
	}

C
Casey Schaufler 已提交
2758
	return rc;
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
}

/**
 * smack_unix_may_send - Smack access on UDS
 * @sock: one socket
 * @other: the other socket
 *
 * Return 0 if a subject with the smack of sock could access
 * an object with the smack of other, otherwise an error code
 */
static int smack_unix_may_send(struct socket *sock, struct socket *other)
{
C
Casey Schaufler 已提交
2771 2772
	struct socket_smack *ssp = sock->sk->sk_security;
	struct socket_smack *osp = other->sk->sk_security;
E
Etienne Basset 已提交
2773
	struct smk_audit_info ad;
C
Casey Schaufler 已提交
2774
	int rc = 0;
2775

2776 2777 2778
#ifdef CONFIG_AUDIT
	struct lsm_network_audit net;

2779
	smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
E
Etienne Basset 已提交
2780
	smk_ad_setfield_u_net_sk(&ad, other->sk);
2781
#endif
C
Casey Schaufler 已提交
2782

2783
	if (!smack_privileged(CAP_MAC_OVERRIDE))
C
Casey Schaufler 已提交
2784 2785 2786
		rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);

	return rc;
2787 2788
}

2789 2790 2791
/**
 * smack_socket_sendmsg - Smack check based on destination host
 * @sock: the socket
2792
 * @msg: the message
2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
 * @size: the size of the message
 *
 * Return 0 if the current subject can write to the destination
 * host. This is only a question if the destination is a single
 * label host.
 */
static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
				int size)
{
	struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;

	/*
	 * Perfectly reasonable for this to be NULL
	 */
2807
	if (sip == NULL || sip->sin_family != AF_INET)
2808 2809
		return 0;

2810
	return smack_netlabel_send(sock->sk, sip);
2811 2812
}

2813
/**
2814
 * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack
2815
 * @sap: netlabel secattr
2816
 * @ssp: socket security information
2817
 *
2818
 * Returns a pointer to a Smack label found on the label list.
2819
 */
2820 2821
static char *smack_from_secattr(struct netlbl_lsm_secattr *sap,
				struct socket_smack *ssp)
2822
{
2823
	struct smack_known *kp;
2824
	char *sp;
2825
	int found = 0;
2826

2827
	if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
2828
		/*
2829
		 * Looks like a CIPSO packet.
2830 2831 2832
		 * If there are flags but no level netlabel isn't
		 * behaving the way we expect it to.
		 *
2833
		 * Look it up in the label table
2834 2835 2836 2837
		 * Without guidance regarding the smack value
		 * for the packet fall back on the network
		 * ambient value.
		 */
2838 2839 2840 2841 2842 2843 2844 2845 2846 2847
		rcu_read_lock();
		list_for_each_entry(kp, &smack_known_list, list) {
			if (sap->attr.mls.lvl != kp->smk_netlabel.attr.mls.lvl)
				continue;
			if (memcmp(sap->attr.mls.cat,
				kp->smk_netlabel.attr.mls.cat,
				SMK_CIPSOLEN) != 0)
				continue;
			found = 1;
			break;
2848
		}
2849 2850 2851 2852 2853
		rcu_read_unlock();

		if (found)
			return kp->smk_known;

2854 2855 2856
		if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known)
			return smack_known_web.smk_known;
		return smack_known_star.smk_known;
2857
	}
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870
	if ((sap->flags & NETLBL_SECATTR_SECID) != 0) {
		/*
		 * Looks like a fallback, which gives us a secid.
		 */
		sp = smack_from_secid(sap->attr.secid);
		/*
		 * This has got to be a bug because it is
		 * impossible to specify a fallback without
		 * specifying the label, which will ensure
		 * it has a secid, and the only way to get a
		 * secid is from a fallback.
		 */
		BUG_ON(sp == NULL);
2871
		return sp;
2872 2873
	}
	/*
2874 2875 2876
	 * Without guidance regarding the smack value
	 * for the packet fall back on the network
	 * ambient value.
2877
	 */
2878
	return smack_net_ambient;
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
}

/**
 * smack_socket_sock_rcv_skb - Smack packet delivery access check
 * @sk: socket
 * @skb: packet
 *
 * Returns 0 if the packet should be delivered, an error code otherwise
 */
static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
	struct netlbl_lsm_secattr secattr;
	struct socket_smack *ssp = sk->sk_security;
2892
	char *csp;
2893
	int rc;
E
Etienne Basset 已提交
2894
	struct smk_audit_info ad;
2895
#ifdef CONFIG_AUDIT
2896
	struct lsm_network_audit net;
2897
#endif
2898 2899 2900 2901 2902 2903 2904
	if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
		return 0;

	/*
	 * Translate what netlabel gave us.
	 */
	netlbl_secattr_init(&secattr);
2905

2906
	rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
2907 2908 2909
	if (rc == 0)
		csp = smack_from_secattr(&secattr, ssp);
	else
2910 2911
		csp = smack_net_ambient;

2912
	netlbl_secattr_destroy(&secattr);
2913

E
Etienne Basset 已提交
2914
#ifdef CONFIG_AUDIT
2915 2916 2917
	smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
	ad.a.u.net->family = sk->sk_family;
	ad.a.u.net->netif = skb->skb_iif;
E
Etienne Basset 已提交
2918 2919
	ipv4_skb_to_auditdata(skb, &ad.a, NULL);
#endif
2920 2921 2922 2923 2924 2925
	/*
	 * Receiving a packet requires that the other end
	 * be able to write here. Read access is not required.
	 * This is the simplist possible security model
	 * for networking.
	 */
E
Etienne Basset 已提交
2926
	rc = smk_access(csp, ssp->smk_in, MAY_WRITE, &ad);
2927 2928 2929
	if (rc != 0)
		netlbl_skbuff_err(skb, rc, 0);
	return rc;
2930 2931 2932 2933 2934 2935 2936
}

/**
 * smack_socket_getpeersec_stream - pull in packet label
 * @sock: the socket
 * @optval: user's destination
 * @optlen: size thereof
2937
 * @len: max thereof
2938 2939 2940 2941 2942 2943 2944 2945
 *
 * returns zero on success, an error code otherwise
 */
static int smack_socket_getpeersec_stream(struct socket *sock,
					  char __user *optval,
					  int __user *optlen, unsigned len)
{
	struct socket_smack *ssp;
2946 2947
	char *rcp = "";
	int slen = 1;
2948 2949 2950
	int rc = 0;

	ssp = sock->sk->sk_security;
2951 2952 2953 2954
	if (ssp->smk_packet != NULL) {
		rcp = ssp->smk_packet;
		slen = strlen(rcp) + 1;
	}
2955 2956 2957

	if (slen > len)
		rc = -ERANGE;
2958
	else if (copy_to_user(optval, rcp, slen) != 0)
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
		rc = -EFAULT;

	if (put_user(slen, optlen) != 0)
		rc = -EFAULT;

	return rc;
}


/**
 * smack_socket_getpeersec_dgram - pull in packet label
C
Casey Schaufler 已提交
2970
 * @sock: the peer socket
2971 2972 2973 2974 2975 2976 2977 2978 2979 2980
 * @skb: packet data
 * @secid: pointer to where to put the secid of the packet
 *
 * Sets the netlabel socket state on sk from parent
 */
static int smack_socket_getpeersec_dgram(struct socket *sock,
					 struct sk_buff *skb, u32 *secid)

{
	struct netlbl_lsm_secattr secattr;
2981 2982
	struct socket_smack *ssp = NULL;
	char *sp;
C
Casey Schaufler 已提交
2983 2984
	int family = PF_UNSPEC;
	u32 s = 0;	/* 0 is the invalid secid */
2985 2986
	int rc;

C
Casey Schaufler 已提交
2987 2988 2989 2990 2991
	if (skb != NULL) {
		if (skb->protocol == htons(ETH_P_IP))
			family = PF_INET;
		else if (skb->protocol == htons(ETH_P_IPV6))
			family = PF_INET6;
2992
	}
C
Casey Schaufler 已提交
2993 2994
	if (family == PF_UNSPEC && sock != NULL)
		family = sock->sk->sk_family;
2995

C
Casey Schaufler 已提交
2996
	if (family == PF_UNIX) {
2997 2998
		ssp = sock->sk->sk_security;
		s = smack_to_secid(ssp->smk_out);
C
Casey Schaufler 已提交
2999 3000 3001 3002
	} else if (family == PF_INET || family == PF_INET6) {
		/*
		 * Translate what netlabel gave us.
		 */
3003 3004
		if (sock != NULL && sock->sk != NULL)
			ssp = sock->sk->sk_security;
C
Casey Schaufler 已提交
3005 3006 3007
		netlbl_secattr_init(&secattr);
		rc = netlbl_skbuff_getattr(skb, family, &secattr);
		if (rc == 0) {
3008 3009
			sp = smack_from_secattr(&secattr, ssp);
			s = smack_to_secid(sp);
C
Casey Schaufler 已提交
3010 3011 3012 3013
		}
		netlbl_secattr_destroy(&secattr);
	}
	*secid = s;
3014 3015 3016 3017 3018 3019
	if (s == 0)
		return -EINVAL;
	return 0;
}

/**
3020 3021 3022
 * smack_sock_graft - Initialize a newly created socket with an existing sock
 * @sk: child sock
 * @parent: parent socket
3023
 *
3024 3025
 * Set the smk_{in,out} state of an existing sock based on the process that
 * is creating the new socket.
3026 3027 3028 3029 3030
 */
static void smack_sock_graft(struct sock *sk, struct socket *parent)
{
	struct socket_smack *ssp;

3031 3032
	if (sk == NULL ||
	    (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
3033 3034 3035
		return;

	ssp = sk->sk_security;
3036
	ssp->smk_in = ssp->smk_out = smk_of_current();
3037
	/* cssp->smk_packet is already set in smack_inet_csk_clone() */
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051
}

/**
 * smack_inet_conn_request - Smack access check on connect
 * @sk: socket involved
 * @skb: packet
 * @req: unused
 *
 * Returns 0 if a task with the packet label could write to
 * the socket, otherwise an error code
 */
static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
				   struct request_sock *req)
{
3052
	u16 family = sk->sk_family;
3053
	struct smack_known *skp;
3054
	struct socket_smack *ssp = sk->sk_security;
3055 3056 3057
	struct netlbl_lsm_secattr secattr;
	struct sockaddr_in addr;
	struct iphdr *hdr;
3058
	char *sp;
3059
	char *hsp;
3060
	int rc;
E
Etienne Basset 已提交
3061
	struct smk_audit_info ad;
3062
#ifdef CONFIG_AUDIT
3063
	struct lsm_network_audit net;
3064
#endif
3065

3066 3067 3068
	/* handle mapped IPv4 packets arriving via IPv6 sockets */
	if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
		family = PF_INET;
3069

3070 3071
	netlbl_secattr_init(&secattr);
	rc = netlbl_skbuff_getattr(skb, family, &secattr);
3072
	if (rc == 0)
3073
		sp = smack_from_secattr(&secattr, ssp);
3074
	else
3075
		sp = smack_known_huh.smk_known;
3076 3077
	netlbl_secattr_destroy(&secattr);

E
Etienne Basset 已提交
3078
#ifdef CONFIG_AUDIT
3079 3080 3081
	smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
	ad.a.u.net->family = family;
	ad.a.u.net->netif = skb->skb_iif;
E
Etienne Basset 已提交
3082 3083
	ipv4_skb_to_auditdata(skb, &ad.a, NULL);
#endif
3084
	/*
3085 3086
	 * Receiving a packet requires that the other end be able to write
	 * here. Read access is not required.
3087
	 */
3088
	rc = smk_access(sp, ssp->smk_in, MAY_WRITE, &ad);
3089 3090 3091 3092 3093 3094 3095
	if (rc != 0)
		return rc;

	/*
	 * Save the peer's label in the request_sock so we can later setup
	 * smk_packet in the child socket so that SO_PEERCRED can report it.
	 */
3096
	req->peer_secid = smack_to_secid(sp);
3097 3098 3099 3100

	/*
	 * We need to decide if we want to label the incoming connection here
	 * if we do we only need to label the request_sock and the stack will
L
Lucas De Marchi 已提交
3101
	 * propagate the wire-label to the sock when it is created.
3102 3103 3104 3105
	 */
	hdr = ip_hdr(skb);
	addr.sin_addr.s_addr = hdr->saddr;
	rcu_read_lock();
3106 3107 3108 3109 3110 3111 3112
	hsp = smack_host_label(&addr);
	rcu_read_unlock();

	if (hsp == NULL) {
		skp = smk_find_entry(sp);
		rc = netlbl_req_setattr(req, &skp->smk_netlabel);
	} else
3113
		netlbl_req_delattr(req);
3114 3115 3116 3117

	return rc;
}

3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
/**
 * smack_inet_csk_clone - Copy the connection information to the new socket
 * @sk: the new socket
 * @req: the connection's request_sock
 *
 * Transfer the connection's peer label to the newly created socket.
 */
static void smack_inet_csk_clone(struct sock *sk,
				 const struct request_sock *req)
{
	struct socket_smack *ssp = sk->sk_security;

3130 3131 3132 3133
	if (req->peer_secid != 0)
		ssp->smk_packet = smack_from_secid(req->peer_secid);
	else
		ssp->smk_packet = NULL;
3134 3135
}

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
/*
 * Key management security hooks
 *
 * Casey has not tested key support very heavily.
 * The permission check is most likely too restrictive.
 * If you care about keys please have a look.
 */
#ifdef CONFIG_KEYS

/**
 * smack_key_alloc - Set the key security blob
 * @key: object
D
David Howells 已提交
3148
 * @cred: the credentials to use
3149 3150 3151 3152 3153 3154
 * @flags: unused
 *
 * No allocation required
 *
 * Returns 0
 */
D
David Howells 已提交
3155
static int smack_key_alloc(struct key *key, const struct cred *cred,
3156 3157
			   unsigned long flags)
{
3158
	key->security = smk_of_task(cred->security);
3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
	return 0;
}

/**
 * smack_key_free - Clear the key security blob
 * @key: the object
 *
 * Clear the blob pointer
 */
static void smack_key_free(struct key *key)
{
	key->security = NULL;
}

/*
 * smack_key_permission - Smack access on a key
 * @key_ref: gets to the object
D
David Howells 已提交
3176
 * @cred: the credentials to use
3177 3178 3179 3180 3181 3182
 * @perm: unused
 *
 * Return 0 if the task has read and write to the object,
 * an error code otherwise
 */
static int smack_key_permission(key_ref_t key_ref,
D
David Howells 已提交
3183
				const struct cred *cred, key_perm_t perm)
3184 3185
{
	struct key *keyp;
E
Etienne Basset 已提交
3186
	struct smk_audit_info ad;
3187
	char *tsp = smk_of_task(cred->security);
3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200

	keyp = key_ref_to_ptr(key_ref);
	if (keyp == NULL)
		return -EINVAL;
	/*
	 * If the key hasn't been initialized give it access so that
	 * it may do so.
	 */
	if (keyp->security == NULL)
		return 0;
	/*
	 * This should not occur
	 */
3201
	if (tsp == NULL)
3202
		return -EACCES;
E
Etienne Basset 已提交
3203 3204 3205 3206 3207
#ifdef CONFIG_AUDIT
	smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
	ad.a.u.key_struct.key = keyp->serial;
	ad.a.u.key_struct.key_desc = keyp->description;
#endif
3208
	return smk_access(tsp, keyp->security,
E
Etienne Basset 已提交
3209
				 MAY_READWRITE, &ad);
3210 3211 3212
}
#endif /* CONFIG_KEYS */

3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245
/*
 * Smack Audit hooks
 *
 * Audit requires a unique representation of each Smack specific
 * rule. This unique representation is used to distinguish the
 * object to be audited from remaining kernel objects and also
 * works as a glue between the audit hooks.
 *
 * Since repository entries are added but never deleted, we'll use
 * the smack_known label address related to the given audit rule as
 * the needed unique representation. This also better fits the smack
 * model where nearly everything is a label.
 */
#ifdef CONFIG_AUDIT

/**
 * smack_audit_rule_init - Initialize a smack audit rule
 * @field: audit rule fields given from user-space (audit.h)
 * @op: required testing operator (=, !=, >, <, ...)
 * @rulestr: smack label to be audited
 * @vrule: pointer to save our own audit rule representation
 *
 * Prepare to audit cases where (@field @op @rulestr) is true.
 * The label to be audited is created if necessay.
 */
static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
{
	char **rule = (char **)vrule;
	*rule = NULL;

	if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
		return -EINVAL;

3246
	if (op != Audit_equal && op != Audit_not_equal)
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294
		return -EINVAL;

	*rule = smk_import(rulestr, 0);

	return 0;
}

/**
 * smack_audit_rule_known - Distinguish Smack audit rules
 * @krule: rule of interest, in Audit kernel representation format
 *
 * This is used to filter Smack rules from remaining Audit ones.
 * If it's proved that this rule belongs to us, the
 * audit_rule_match hook will be called to do the final judgement.
 */
static int smack_audit_rule_known(struct audit_krule *krule)
{
	struct audit_field *f;
	int i;

	for (i = 0; i < krule->field_count; i++) {
		f = &krule->fields[i];

		if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
			return 1;
	}

	return 0;
}

/**
 * smack_audit_rule_match - Audit given object ?
 * @secid: security id for identifying the object to test
 * @field: audit rule flags given from user-space
 * @op: required testing operator
 * @vrule: smack internal rule presentation
 * @actx: audit context associated with the check
 *
 * The core Audit hook. It's used to take the decision of
 * whether to audit or not to audit a given object.
 */
static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
				  struct audit_context *actx)
{
	char *smack;
	char *rule = vrule;

	if (!rule) {
3295
		audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR,
3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309
			  "Smack: missing rule\n");
		return -ENOENT;
	}

	if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
		return 0;

	smack = smack_from_secid(secid);

	/*
	 * No need to do string comparisons. If a match occurs,
	 * both pointers will point to the same smack_known
	 * label.
	 */
3310
	if (op == Audit_equal)
3311
		return (rule == smack);
3312
	if (op == Audit_not_equal)
3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330
		return (rule != smack);

	return 0;
}

/**
 * smack_audit_rule_free - free smack rule representation
 * @vrule: rule to be freed.
 *
 * No memory was allocated.
 */
static void smack_audit_rule_free(void *vrule)
{
	/* No-op */
}

#endif /* CONFIG_AUDIT */

3331
/**
3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342
 * smack_secid_to_secctx - return the smack label for a secid
 * @secid: incoming integer
 * @secdata: destination
 * @seclen: how long it is
 *
 * Exists for networking code.
 */
static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
	char *sp = smack_from_secid(secid);

3343 3344
	if (secdata)
		*secdata = sp;
3345 3346 3347 3348
	*seclen = strlen(sp);
	return 0;
}

3349
/**
3350 3351 3352 3353 3354 3355 3356
 * smack_secctx_to_secid - return the secid for a smack label
 * @secdata: smack label
 * @seclen: how long result is
 * @secid: outgoing integer
 *
 * Exists for audit and networking code.
 */
3357
static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
3358 3359 3360 3361 3362
{
	*secid = smack_to_secid(secdata);
	return 0;
}

3363
/**
3364
 * smack_release_secctx - don't do anything.
3365 3366
 * @secdata: unused
 * @seclen: unused
3367 3368 3369 3370 3371 3372 3373
 *
 * Exists to make sure nothing gets done, and properly
 */
static void smack_release_secctx(char *secdata, u32 seclen)
{
}

3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
{
	return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0);
}

static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
{
	return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0);
}

static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
{
	int len = 0;
	len = smack_inode_getsecurity(inode, XATTR_SMACK_SUFFIX, ctx, true);

	if (len < 0)
		return len;
	*ctxlen = len;
	return 0;
}

3395 3396 3397
struct security_operations smack_ops = {
	.name =				"smack",

3398
	.ptrace_access_check =		smack_ptrace_access_check,
3399
	.ptrace_traceme =		smack_ptrace_traceme,
3400 3401 3402 3403 3404 3405 3406 3407 3408 3409
	.syslog = 			smack_syslog,

	.sb_alloc_security = 		smack_sb_alloc_security,
	.sb_free_security = 		smack_sb_free_security,
	.sb_copy_data = 		smack_sb_copy_data,
	.sb_kern_mount = 		smack_sb_kern_mount,
	.sb_statfs = 			smack_sb_statfs,
	.sb_mount = 			smack_sb_mount,
	.sb_umount = 			smack_sb_umount,

3410
	.bprm_set_creds =		smack_bprm_set_creds,
3411 3412
	.bprm_committing_creds =	smack_bprm_committing_creds,
	.bprm_secureexec =		smack_bprm_secureexec,
3413

3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
	.inode_alloc_security = 	smack_inode_alloc_security,
	.inode_free_security = 		smack_inode_free_security,
	.inode_init_security = 		smack_inode_init_security,
	.inode_link = 			smack_inode_link,
	.inode_unlink = 		smack_inode_unlink,
	.inode_rmdir = 			smack_inode_rmdir,
	.inode_rename = 		smack_inode_rename,
	.inode_permission = 		smack_inode_permission,
	.inode_setattr = 		smack_inode_setattr,
	.inode_getattr = 		smack_inode_getattr,
	.inode_setxattr = 		smack_inode_setxattr,
	.inode_post_setxattr = 		smack_inode_post_setxattr,
	.inode_getxattr = 		smack_inode_getxattr,
	.inode_removexattr = 		smack_inode_removexattr,
	.inode_getsecurity = 		smack_inode_getsecurity,
	.inode_setsecurity = 		smack_inode_setsecurity,
	.inode_listsecurity = 		smack_inode_listsecurity,
3431
	.inode_getsecid =		smack_inode_getsecid,
3432 3433 3434 3435 3436 3437 3438

	.file_permission = 		smack_file_permission,
	.file_alloc_security = 		smack_file_alloc_security,
	.file_free_security = 		smack_file_free_security,
	.file_ioctl = 			smack_file_ioctl,
	.file_lock = 			smack_file_lock,
	.file_fcntl = 			smack_file_fcntl,
3439 3440
	.mmap_file =			smack_mmap_file,
	.mmap_addr =			cap_mmap_addr,
3441 3442 3443 3444
	.file_set_fowner = 		smack_file_set_fowner,
	.file_send_sigiotask = 		smack_file_send_sigiotask,
	.file_receive = 		smack_file_receive,

3445
	.file_open =			smack_file_open,
3446

3447
	.cred_alloc_blank =		smack_cred_alloc_blank,
3448
	.cred_free =			smack_cred_free,
D
David Howells 已提交
3449
	.cred_prepare =			smack_cred_prepare,
3450
	.cred_transfer =		smack_cred_transfer,
3451 3452
	.kernel_act_as =		smack_kernel_act_as,
	.kernel_create_files_as =	smack_kernel_create_files_as,
3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467
	.task_setpgid = 		smack_task_setpgid,
	.task_getpgid = 		smack_task_getpgid,
	.task_getsid = 			smack_task_getsid,
	.task_getsecid = 		smack_task_getsecid,
	.task_setnice = 		smack_task_setnice,
	.task_setioprio = 		smack_task_setioprio,
	.task_getioprio = 		smack_task_getioprio,
	.task_setscheduler = 		smack_task_setscheduler,
	.task_getscheduler = 		smack_task_getscheduler,
	.task_movememory = 		smack_task_movememory,
	.task_kill = 			smack_task_kill,
	.task_wait = 			smack_task_wait,
	.task_to_inode = 		smack_task_to_inode,

	.ipc_permission = 		smack_ipc_permission,
3468
	.ipc_getsecid =			smack_ipc_getsecid,
3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500

	.msg_msg_alloc_security = 	smack_msg_msg_alloc_security,
	.msg_msg_free_security = 	smack_msg_msg_free_security,

	.msg_queue_alloc_security = 	smack_msg_queue_alloc_security,
	.msg_queue_free_security = 	smack_msg_queue_free_security,
	.msg_queue_associate = 		smack_msg_queue_associate,
	.msg_queue_msgctl = 		smack_msg_queue_msgctl,
	.msg_queue_msgsnd = 		smack_msg_queue_msgsnd,
	.msg_queue_msgrcv = 		smack_msg_queue_msgrcv,

	.shm_alloc_security = 		smack_shm_alloc_security,
	.shm_free_security = 		smack_shm_free_security,
	.shm_associate = 		smack_shm_associate,
	.shm_shmctl = 			smack_shm_shmctl,
	.shm_shmat = 			smack_shm_shmat,

	.sem_alloc_security = 		smack_sem_alloc_security,
	.sem_free_security = 		smack_sem_free_security,
	.sem_associate = 		smack_sem_associate,
	.sem_semctl = 			smack_sem_semctl,
	.sem_semop = 			smack_sem_semop,

	.d_instantiate = 		smack_d_instantiate,

	.getprocattr = 			smack_getprocattr,
	.setprocattr = 			smack_setprocattr,

	.unix_stream_connect = 		smack_unix_stream_connect,
	.unix_may_send = 		smack_unix_may_send,

	.socket_post_create = 		smack_socket_post_create,
3501 3502
	.socket_connect =		smack_socket_connect,
	.socket_sendmsg =		smack_socket_sendmsg,
3503 3504 3505 3506 3507 3508 3509
	.socket_sock_rcv_skb = 		smack_socket_sock_rcv_skb,
	.socket_getpeersec_stream =	smack_socket_getpeersec_stream,
	.socket_getpeersec_dgram =	smack_socket_getpeersec_dgram,
	.sk_alloc_security = 		smack_sk_alloc_security,
	.sk_free_security = 		smack_sk_free_security,
	.sock_graft = 			smack_sock_graft,
	.inet_conn_request = 		smack_inet_conn_request,
3510
	.inet_csk_clone =		smack_inet_csk_clone,
3511

3512 3513 3514 3515 3516 3517
 /* key management security hooks */
#ifdef CONFIG_KEYS
	.key_alloc = 			smack_key_alloc,
	.key_free = 			smack_key_free,
	.key_permission = 		smack_key_permission,
#endif /* CONFIG_KEYS */
3518 3519 3520 3521 3522 3523 3524 3525 3526

 /* Audit hooks */
#ifdef CONFIG_AUDIT
	.audit_rule_init =		smack_audit_rule_init,
	.audit_rule_known =		smack_audit_rule_known,
	.audit_rule_match =		smack_audit_rule_match,
	.audit_rule_free =		smack_audit_rule_free,
#endif /* CONFIG_AUDIT */

3527
	.secid_to_secctx = 		smack_secid_to_secctx,
3528
	.secctx_to_secid = 		smack_secctx_to_secid,
3529
	.release_secctx = 		smack_release_secctx,
3530 3531 3532
	.inode_notifysecctx =		smack_inode_notifysecctx,
	.inode_setsecctx =		smack_inode_setsecctx,
	.inode_getsecctx =		smack_inode_getsecctx,
3533 3534
};

3535

3536
static __init void init_smack_known_list(void)
3537
{
3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558
	/*
	 * Initialize rule list locks
	 */
	mutex_init(&smack_known_huh.smk_rules_lock);
	mutex_init(&smack_known_hat.smk_rules_lock);
	mutex_init(&smack_known_floor.smk_rules_lock);
	mutex_init(&smack_known_star.smk_rules_lock);
	mutex_init(&smack_known_invalid.smk_rules_lock);
	mutex_init(&smack_known_web.smk_rules_lock);
	/*
	 * Initialize rule lists
	 */
	INIT_LIST_HEAD(&smack_known_huh.smk_rules);
	INIT_LIST_HEAD(&smack_known_hat.smk_rules);
	INIT_LIST_HEAD(&smack_known_star.smk_rules);
	INIT_LIST_HEAD(&smack_known_floor.smk_rules);
	INIT_LIST_HEAD(&smack_known_invalid.smk_rules);
	INIT_LIST_HEAD(&smack_known_web.smk_rules);
	/*
	 * Create the known labels list
	 */
3559 3560 3561 3562 3563 3564 3565 3566
	list_add(&smack_known_huh.list, &smack_known_list);
	list_add(&smack_known_hat.list, &smack_known_list);
	list_add(&smack_known_star.list, &smack_known_list);
	list_add(&smack_known_floor.list, &smack_known_list);
	list_add(&smack_known_invalid.list, &smack_known_list);
	list_add(&smack_known_web.list, &smack_known_list);
}

3567 3568 3569 3570 3571 3572 3573
/**
 * smack_init - initialize the smack system
 *
 * Returns 0
 */
static __init int smack_init(void)
{
D
David Howells 已提交
3574
	struct cred *cred;
3575
	struct task_smack *tsp;
D
David Howells 已提交
3576

3577 3578 3579 3580 3581
	if (!security_module_enable(&smack_ops))
		return 0;

	tsp = new_task_smack(smack_known_floor.smk_known,
				smack_known_floor.smk_known, GFP_KERNEL);
3582 3583 3584
	if (tsp == NULL)
		return -ENOMEM;

3585 3586 3587 3588 3589
	printk(KERN_INFO "Smack:  Initializing.\n");

	/*
	 * Set the security state for the initial task.
	 */
D
David Howells 已提交
3590
	cred = (struct cred *) current->cred;
3591
	cred->security = tsp;
3592

3593 3594
	/* initialize the smack_known_list */
	init_smack_known_list();
3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609

	/*
	 * Register with LSM
	 */
	if (register_security(&smack_ops))
		panic("smack: Unable to register with kernel.\n");

	return 0;
}

/*
 * Smack requires early initialization in order to label
 * all processes and objects when they are created.
 */
security_initcall(smack_init);