Release 4.10 security/apparmor/lsm.c

Directory: security/apparmor
/*
 * AppArmor security module
 *
 * This file contains AppArmor LSM hooks.
 *
 * Copyright (C) 1998-2008 Novell/SUSE
 * Copyright 2009-2010 Canonical Ltd.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, version 2 of the
 * License.
 */

#include <linux/lsm_hooks.h>
#include <linux/moduleparam.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/ptrace.h>
#include <linux/ctype.h>
#include <linux/sysctl.h>
#include <linux/audit.h>
#include <linux/user_namespace.h>
#include <net/sock.h>

#include "include/apparmor.h"
#include "include/apparmorfs.h"
#include "include/audit.h"
#include "include/capability.h"
#include "include/context.h"
#include "include/file.h"
#include "include/ipc.h"
#include "include/path.h"
#include "include/policy.h"
#include "include/procattr.h"

/* Flag indicating whether initialization completed */

int apparmor_initialized __initdata;

/*
 * LSM hook functions
 */

/*
 * free the associated aa_task_cxt and put its profiles
 */


static void apparmor_cred_free(struct cred *cred)
{
	aa_free_task_context(cred_cxt(cred));
	cred_cxt(cred) = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%

/*
 * allocate the apparmor part of blank credentials
 */


static int apparmor_cred_alloc_blank(struct cred *cred, gfp_t gfp)
{
	/* freed by apparmor_cred_free */
	struct aa_task_cxt *cxt = aa_alloc_task_context(gfp);
	if (!cxt)
		return -ENOMEM;

	cred_cxt(cred) = cxt;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 44 100.00% 2 100.00%
Total 44 100.00% 2 100.00%

/*
 * prepare new aa_task_cxt for modification by prepare_cred block
 */


static int apparmor_cred_prepare(struct cred *new, const struct cred *old,
				 gfp_t gfp)
{
	/* freed by apparmor_cred_free */
	struct aa_task_cxt *cxt = aa_alloc_task_context(gfp);
	if (!cxt)
		return -ENOMEM;

	aa_dup_task_context(cxt, cred_cxt(old));
	cred_cxt(new) = cxt;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 60 100.00% 2 100.00%
Total 60 100.00% 2 100.00%

/*
 * transfer the apparmor data to a blank set of creds
 */


static void apparmor_cred_transfer(struct cred *new, const struct cred *old)
{
	const struct aa_task_cxt *old_cxt = cred_cxt(old);
	struct aa_task_cxt *new_cxt = cred_cxt(new);

	aa_dup_task_context(new_cxt, old_cxt);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 45 100.00% 2 100.00%
Total 45 100.00% 2 100.00%



static int apparmor_ptrace_access_check(struct task_struct *child,
					unsigned int mode)
{
	return aa_ptrace(current, child, mode);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static int apparmor_ptrace_traceme(struct task_struct *parent)
{
	return aa_ptrace(parent, current, PTRACE_MODE_ATTACH);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

/* Derived from security/commoncap.c:cap_capget */


static int apparmor_capget(struct task_struct *target, kernel_cap_t *effective,
			   kernel_cap_t *inheritable, kernel_cap_t *permitted)
{
	struct aa_profile *profile;
	const struct cred *cred;

	rcu_read_lock();
	cred = __task_cred(target);
	profile = aa_cred_profile(cred);

	/*
         * cap_capget is stacked ahead of this and will
         * initialize effective and permitted.
         */
	if (!unconfined(profile) && !COMPLAIN_MODE(profile)) {
		*effective = cap_intersect(*effective, profile->caps.allow);
		*permitted = cap_intersect(*permitted, profile->caps.allow);
	}
	rcu_read_unlock();

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 103 99.04% 2 66.67%
casey schaufler casey schaufler 1 0.96% 1 33.33%
Total 104 100.00% 3 100.00%



static int apparmor_capable(const struct cred *cred, struct user_namespace *ns,
			    int cap, int audit)
{
	struct aa_profile *profile;
	int error = 0;

	profile = aa_cred_profile(cred);
	if (!unconfined(profile))
		error = aa_capable(profile, cap, audit);
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 56 90.32% 1 33.33%
serge hallyn serge hallyn 5 8.06% 1 33.33%
casey schaufler casey schaufler 1 1.61% 1 33.33%
Total 62 100.00% 3 100.00%

/**
 * common_perm - basic common permission check wrapper fn for paths
 * @op: operation being checked
 * @path: path to check permission of  (NOT NULL)
 * @mask: requested permissions mask
 * @cond: conditional info for the permission request  (NOT NULL)
 *
 * Returns: %0 else error code if error or permission denied
 */


static int common_perm(int op, const struct path *path, u32 mask,
		       struct path_cond *cond)
{
	struct aa_profile *profile;
	int error = 0;

	profile = __aa_current_profile();
	if (!unconfined(profile))
		error = aa_path_perm(op, profile, path, 0, mask, cond);

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 65 98.48% 1 50.00%
al viro al viro 1 1.52% 1 50.00%
Total 66 100.00% 2 100.00%

/**
 * common_perm_dir_dentry - common permission wrapper when path is dir, dentry
 * @op: operation being checked
 * @dir: directory of the dentry  (NOT NULL)
 * @dentry: dentry to check  (NOT NULL)
 * @mask: requested permissions mask
 * @cond: conditional info for the permission request  (NOT NULL)
 *
 * Returns: %0 else error code if error or permission denied
 */


static int common_perm_dir_dentry(int op, const struct path *dir,
				  struct dentry *dentry, u32 mask,
				  struct path_cond *cond)
{
	struct path path = { dir->mnt, dentry };

	return common_perm(op, &path, mask, cond);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 52 98.11% 1 50.00%
al viro al viro 1 1.89% 1 50.00%
Total 53 100.00% 2 100.00%

/**
 * common_perm_path - common permission wrapper when mnt, dentry
 * @op: operation being checked
 * @path: location to check (NOT NULL)
 * @mask: requested permissions mask
 *
 * Returns: %0 else error code if error or permission denied
 */


static inline int common_perm_path(int op, const struct path *path, u32 mask)
{
	struct path_cond cond = { d_backing_inode(path->dentry)->i_uid,
				  d_backing_inode(path->dentry)->i_mode
	};
	if (!mediated_filesystem(path->dentry))
		return 0;

	return common_perm(op, path, mask, &cond);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 41 59.42% 1 33.33%
al viro al viro 22 31.88% 1 33.33%
david howells david howells 6 8.70% 1 33.33%
Total 69 100.00% 3 100.00%

/**
 * common_perm_rm - common permission wrapper for operations doing rm
 * @op: operation being checked
 * @dir: directory that the dentry is in  (NOT NULL)
 * @dentry: dentry being rm'd  (NOT NULL)
 * @mask: requested permission mask
 *
 * Returns: %0 else error code if error or permission denied
 */


static int common_perm_rm(int op, const struct path *dir,
			  struct dentry *dentry, u32 mask)
{
	struct inode *inode = d_backing_inode(dentry);
	struct path_cond cond = { };

	if (!inode || !mediated_filesystem(dentry))
		return 0;

	cond.uid = inode->i_uid;
	cond.mode = inode->i_mode;

	return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 79 94.05% 1 25.00%
david howells david howells 4 4.76% 2 50.00%
al viro al viro 1 1.19% 1 25.00%
Total 84 100.00% 4 100.00%

/**
 * common_perm_create - common permission wrapper for operations doing create
 * @op: operation being checked
 * @dir: directory that dentry will be created in  (NOT NULL)
 * @dentry: dentry to create   (NOT NULL)
 * @mask: request permission mask
 * @mode: created file mode
 *
 * Returns: %0 else error code if error or permission denied
 */


static int common_perm_create(int op, const struct path *dir,
			      struct dentry *dentry, u32 mask, umode_t mode)
{
	struct path_cond cond = { current_fsuid(), mode };

	if (!mediated_filesystem(dir->dentry))
		return 0;

	return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 64 98.46% 1 50.00%
al viro al viro 1 1.54% 1 50.00%
Total 65 100.00% 2 100.00%



static int apparmor_path_unlink(const struct path *dir, struct dentry *dentry)
{
	return common_perm_rm(OP_UNLINK, dir, dentry, AA_MAY_DELETE);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 28 96.55% 1 50.00%
al viro al viro 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



static int apparmor_path_mkdir(const struct path *dir, struct dentry *dentry,
			       umode_t mode)
{
	return common_perm_create(OP_MKDIR, dir, dentry, AA_MAY_CREATE,
				  S_IFDIR);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 32 94.12% 1 33.33%
al viro al viro 2 5.88% 2 66.67%
Total 34 100.00% 3 100.00%



static int apparmor_path_rmdir(const struct path *dir, struct dentry *dentry)
{
	return common_perm_rm(OP_RMDIR, dir, dentry, AA_MAY_DELETE);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 28 96.55% 1 50.00%
al viro al viro 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



static int apparmor_path_mknod(const struct path *dir, struct dentry *dentry,
			       umode_t mode, unsigned int dev)
{
	return common_perm_create(OP_MKNOD, dir, dentry, AA_MAY_CREATE, mode);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 36 94.74% 1 33.33%
al viro al viro 2 5.26% 2 66.67%
Total 38 100.00% 3 100.00%



static int apparmor_path_truncate(const struct path *path)
{
	return common_perm_path(OP_TRUNC, path, MAY_WRITE | AA_MAY_META_WRITE);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 22 91.67% 1 33.33%
al viro al viro 2 8.33% 2 66.67%
Total 24 100.00% 3 100.00%



static int apparmor_path_symlink(const struct path *dir, struct dentry *dentry,
				 const char *old_name)
{
	return common_perm_create(OP_SYMLINK, dir, dentry, AA_MAY_CREATE,
				  S_IFLNK);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 35 97.22% 1 50.00%
al viro al viro 1 2.78% 1 50.00%
Total 36 100.00% 2 100.00%



static int apparmor_path_link(struct dentry *old_dentry, const struct path *new_dir,
			      struct dentry *new_dentry)
{
	struct aa_profile *profile;
	int error = 0;

	if (!mediated_filesystem(old_dentry))
		return 0;

	profile = aa_current_profile();
	if (!unconfined(profile))
		error = aa_path_link(profile, old_dentry, new_dir, new_dentry);
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 71 98.61% 1 50.00%
al viro al viro 1 1.39% 1 50.00%
Total 72 100.00% 2 100.00%



static int apparmor_path_rename(const struct path *old_dir, struct dentry *old_dentry,
				const struct path *new_dir, struct dentry *new_dentry)
{
	struct aa_profile *profile;
	int error = 0;

	if (!mediated_filesystem(old_dentry))
		return 0;

	profile = aa_current_profile();
	if (!unconfined(profile)) {
		struct path old_path = { old_dir->mnt, old_dentry };
		struct path new_path = { new_dir->mnt, new_dentry };
		struct path_cond cond = { d_backing_inode(old_dentry)->i_uid,
					  d_backing_inode(old_dentry)->i_mode
		};

		error = aa_path_perm(OP_RENAME_SRC, profile, &old_path, 0,
				     MAY_READ | AA_MAY_META_READ | MAY_WRITE |
				     AA_MAY_META_WRITE | AA_MAY_DELETE,
				     &cond);
		if (!error)
			error = aa_path_perm(OP_RENAME_DEST, profile, &new_path,
					     0, MAY_WRITE | AA_MAY_META_WRITE |
					     AA_MAY_CREATE, &cond);

	}
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 158 95.18% 1 33.33%
david howells david howells 6 3.61% 1 33.33%
al viro al viro 2 1.20% 1 33.33%
Total 166 100.00% 3 100.00%



static int apparmor_path_chmod(const struct path *path, umode_t mode)
{
	return common_perm_path(OP_CHMOD, path, AA_MAY_CHMOD);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 19 76.00% 1 20.00%
al viro al viro 6 24.00% 4 80.00%
Total 25 100.00% 5 100.00%



static int apparmor_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
{
	return common_perm_path(OP_CHOWN, path, AA_MAY_CHOWN);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 24 85.71% 1 25.00%
al viro al viro 2 7.14% 2 50.00%
eric w. biederman eric w. biederman 2 7.14% 1 25.00%
Total 28 100.00% 4 100.00%



static int apparmor_inode_getattr(const struct path *path)
{
	return common_perm_path(OP_GETATTR, path, AA_MAY_META_READ);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 17 77.27% 1 33.33%
al viro al viro 5 22.73% 2 66.67%
Total 22 100.00% 3 100.00%



static int apparmor_file_open(struct file *file, const struct cred *cred)
{
	struct aa_file_cxt *fcxt = file->f_security;
	struct aa_profile *profile;
	int error = 0;

	if (!mediated_filesystem(file->f_path.dentry))
		return 0;

	/* If in exec, permission is handled by bprm hooks.
         * Cache permissions granted by the previous exec check, with
         * implicit read and executable mmap which are required to
         * actually execute the image.
         */
	if (current->in_execve) {
		fcxt->allow = MAY_EXEC | MAY_READ | AA_EXEC_MMAP;
		return 0;
	}

	profile = aa_cred_profile(cred);
	if (!unconfined(profile)) {
		struct inode *inode = file_inode(file);
		struct path_cond cond = { inode->i_uid, inode->i_mode };

		error = aa_path_perm(OP_OPEN, profile, &file->f_path, 0,
				     aa_map_file_to_perms(file), &cond);
		/* todo cache full allowed permissions set and state */
		fcxt->allow = aa_map_file_to_perms(file);
	}

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 143 94.70% 1 25.00%
david howells david howells 4 2.65% 1 25.00%
al viro al viro 3 1.99% 1 25.00%
eric paris eric paris 1 0.66% 1 25.00%
Total 151 100.00% 4 100.00%



static int apparmor_file_alloc_security(struct file *file)
{
	/* freed by apparmor_file_free_security */
	file->f_security = aa_alloc_file_context(GFP_KERNEL);
	if (!file->f_security)
		return -ENOMEM;
	return 0;

}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static void apparmor_file_free_security(struct file *file)
{
	struct aa_file_cxt *cxt = file->f_security;

	aa_free_file_context(cxt);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static int common_file_perm(int op, struct file *file, u32 mask)
{
	struct aa_file_cxt *fcxt = file->f_security;
	struct aa_profile *profile, *fprofile = aa_cred_profile(file->f_cred);
	int error = 0;

	BUG_ON(!fprofile);

	if (!file->f_path.mnt ||
	    !mediated_filesystem(file->f_path.dentry))
		return 0;

	profile = __aa_current_profile();

	/* revalidate access, if task is unconfined, or the cached cred
         * doesn't match or if the request is for more permissions than
         * was granted.
         *
         * Note: the test for !unconfined(fprofile) is to handle file
         *       delegation from unconfined tasks
         */
	if (!unconfined(profile) && !unconfined(fprofile) &&
	    ((fprofile != profile) || (mask & ~fcxt->allow)))
		error = aa_file_perm(op, profile, file, mask);

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 123 96.85% 1 50.00%
david howells david howells 4 3.15% 1 50.00%
Total 127 100.00% 2 100.00%



static int apparmor_file_permission(struct file *file, int mask)
{
	return common_file_perm(OP_FPERM, file, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static int apparmor_file_lock(struct file *file, unsigned int cmd)
{
	u32 mask = AA_MAY_LOCK;

	if (cmd == F_WRLCK)
		mask |= MAY_WRITE;

	return common_file_perm(OP_FLOCK, file, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%



static int common_mmap(int op, struct file *file, unsigned long prot,
		       unsigned long flags)
{
	int mask = 0;

	if (!file || !file->f_security)
		return 0;

	if (prot & PROT_READ)
		mask |= MAY_READ;
	/*
         * Private mappings don't require write perms since they don't
         * write back to the files
         */
	if ((prot & PROT_WRITE) && !(flags & MAP_PRIVATE))
		mask |= MAY_WRITE;
	if (prot & PROT_EXEC)
		mask |= AA_EXEC_MMAP;

	return common_file_perm(op, file, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 90 100.00% 1 100.00%
Total 90 100.00% 1 100.00%



static int apparmor_mmap_file(struct file *file, unsigned long reqprot,
			      unsigned long prot, unsigned long flags)
{
	return common_mmap(OP_FMMAP, file, prot, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 34 97.14% 1 50.00%
al viro al viro 1 2.86% 1 50.00%
Total 35 100.00% 2 100.00%



static int apparmor_file_mprotect(struct vm_area_struct *vma,
				  unsigned long reqprot, unsigned long prot)
{
	return common_mmap(OP_FMPROT, vma->vm_file, prot,
			   !(vma->vm_flags & VM_SHARED) ? MAP_PRIVATE : 0);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 44 100.00% 1 100.00%
Total 44 100.00% 1 100.00%



static int apparmor_getprocattr(struct task_struct *task, char *name,
				char **value)
{
	int error = -ENOENT;
	/* released below */
	const struct cred *cred = get_task_cred(task);
	struct aa_task_cxt *cxt = cred_cxt(cred);
	struct aa_profile *profile = NULL;

	if (strcmp(name, "current") == 0)
		profile = aa_get_newest_profile(cxt->profile);
	else if (strcmp(name, "prev") == 0  && cxt->previous)
		profile = aa_get_newest_profile(cxt->previous);
	else if (strcmp(name, "exec") == 0 && cxt->onexec)
		profile = aa_get_newest_profile(cxt->onexec);
	else
		error = -EINVAL;

	if (profile)
		error = aa_getprocattr(profile, value);

	aa_put_profile(profile);
	put_cred(cred);

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 157 100.00% 3 100.00%
Total 157 100.00% 3 100.00%



static int apparmor_setprocattr(struct task_struct *task, char *name,
				void *value, size_t size)
{
	struct common_audit_data sa;
	struct apparmor_audit_data aad = {0,};
	char *command, *largs = NULL, *args = value;
	size_t arg_size;
	int error;

	if (size == 0)
		return -EINVAL;
	/* task can only write its own attributes */
	if (current != task)
		return -EACCES;

	/* AppArmor requires that the buffer must be null terminated atm */
	if (args[size - 1] != '\0') {
		/* null terminate */
		largs = args = kmalloc(size + 1, GFP_KERNEL);
		if (!args)
			return -ENOMEM;
		memcpy(args, value, size);
		args[size] = '\0';
	}

	error = -EINVAL;
	args = strim(args);
	command = strsep(&args, " ");
	if (!args)
		goto out;
	args = skip_spaces(args);
	if (!*args)
		goto out;

	arg_size = size - (args - (largs ? largs : (char *) value));
	if (strcmp(name, "current") == 0) {
		if (strcmp(command, "changehat") == 0) {
			error = aa_setprocattr_changehat(args, arg_size,
							 !AA_DO_TEST);
		} else if (strcmp(command, "permhat") == 0) {
			error = aa_setprocattr_changehat(args, arg_size,
							 AA_DO_TEST);
		} else if (strcmp(command, "changeprofile") == 0) {
			error = aa_setprocattr_changeprofile(args, !AA_ONEXEC,
							     !AA_DO_TEST);
		} else if (strcmp(command, "permprofile") == 0) {
			error = aa_setprocattr_changeprofile(args, !AA_ONEXEC,
							     AA_DO_TEST);
		} else
			goto fail;
	} else if (strcmp(name, "exec") == 0) {
		if (strcmp(command, "exec") == 0)
			error = aa_setprocattr_changeprofile(args, AA_ONEXEC,
							     !AA_DO_TEST);
		else
			goto fail;
	} else
		/* only support the "current" and "exec" process attributes */
		goto fail;

	if (!error)
		error = size;
out:
	kfree(largs);
	return error;

fail:
	sa.type = LSM_AUDIT_DATA_NONE;
	sa.aad = &aad;
	aad.profile = aa_current_profile();
	aad.op = OP_SETPROCATTR;
	aad.info = name;
	aad.error = error = -EINVAL;
	aa_audit_msg(AUDIT_APPARMOR_DENIED, &sa, NULL);
	goto out;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 358 82.30% 3 42.86%
vegard nossum vegard nossum 67 15.40% 1 14.29%
eric paris eric paris 10 2.30% 3 42.86%
Total 435 100.00% 7 100.00%



static int apparmor_task_setrlimit(struct task_struct *task,
		unsigned int resource, struct rlimit *new_rlim)
{
	struct aa_profile *profile = __aa_current_profile();
	int error = 0;

	if (!unconfined(profile))
		error = aa_task_setrlimit(profile, task, resource, new_rlim);

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 52 91.23% 3 75.00%
jiri slaby jiri slaby 5 8.77% 1 25.00%
Total 57 100.00% 4 100.00%


static struct security_hook_list apparmor_hooks[] = {
	LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),
	LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),
	LSM_HOOK_INIT(capget, apparmor_capget),
	LSM_HOOK_INIT(capable, apparmor_capable),

	LSM_HOOK_INIT(path_link, apparmor_path_link),
	LSM_HOOK_INIT(path_unlink, apparmor_path_unlink),
	LSM_HOOK_INIT(path_symlink, apparmor_path_symlink),
	LSM_HOOK_INIT(path_mkdir, apparmor_path_mkdir),
	LSM_HOOK_INIT(path_rmdir, apparmor_path_rmdir),
	LSM_HOOK_INIT(path_mknod, apparmor_path_mknod),
	LSM_HOOK_INIT(path_rename, apparmor_path_rename),
	LSM_HOOK_INIT(path_chmod, apparmor_path_chmod),
	LSM_HOOK_INIT(path_chown, apparmor_path_chown),
	LSM_HOOK_INIT(path_truncate, apparmor_path_truncate),
	LSM_HOOK_INIT(inode_getattr, apparmor_inode_getattr),

	LSM_HOOK_INIT(file_open, apparmor_file_open),
	LSM_HOOK_INIT(file_permission, apparmor_file_permission),
	LSM_HOOK_INIT(file_alloc_security, apparmor_file_alloc_security),
	LSM_HOOK_INIT(file_free_security, apparmor_file_free_security),
	LSM_HOOK_INIT(mmap_file, apparmor_mmap_file),
	LSM_HOOK_INIT(file_mprotect, apparmor_file_mprotect),
	LSM_HOOK_INIT(file_lock, apparmor_file_lock),

	LSM_HOOK_INIT(getprocattr, apparmor_getprocattr),
	LSM_HOOK_INIT(setprocattr, apparmor_setprocattr),

	LSM_HOOK_INIT(cred_alloc_blank, apparmor_cred_alloc_blank),
	LSM_HOOK_INIT(cred_free, apparmor_cred_free),
	LSM_HOOK_INIT(cred_prepare, apparmor_cred_prepare),
	LSM_HOOK_INIT(cred_transfer, apparmor_cred_transfer),

	LSM_HOOK_INIT(bprm_set_creds, apparmor_bprm_set_creds),
	LSM_HOOK_INIT(bprm_committing_creds, apparmor_bprm_committing_creds),
	LSM_HOOK_INIT(bprm_committed_creds, apparmor_bprm_committed_creds),
	LSM_HOOK_INIT(bprm_secureexec, apparmor_bprm_secureexec),

	LSM_HOOK_INIT(task_setrlimit, apparmor_task_setrlimit),
};

/*
 * AppArmor sysfs module parameters
 */

static int param_set_aabool(const char *val, const struct kernel_param *kp);
static int param_get_aabool(char *buffer, const struct kernel_param *kp);

#define param_check_aabool param_check_bool

static const struct kernel_param_ops param_ops_aabool = {
	.flags = KERNEL_PARAM_OPS_FL_NOARG,
	.set = param_set_aabool,
	.get = param_get_aabool
};

static int param_set_aauint(const char *val, const struct kernel_param *kp);
static int param_get_aauint(char *buffer, const struct kernel_param *kp);

#define param_check_aauint param_check_uint

static const struct kernel_param_ops param_ops_aauint = {
	.set = param_set_aauint,
	.get = param_get_aauint
};

static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp);
static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp);

#define param_check_aalockpolicy param_check_bool

static const struct kernel_param_ops param_ops_aalockpolicy = {
	.flags = KERNEL_PARAM_OPS_FL_NOARG,
	.set = param_set_aalockpolicy,
	.get = param_get_aalockpolicy
};

static int param_set_audit(const char *val, struct kernel_param *kp);
static int param_get_audit(char *buffer, struct kernel_param *kp);

static int param_set_mode(const char *val, struct kernel_param *kp);
static int param_get_mode(char *buffer, struct kernel_param *kp);

/* Flag values, also controllable via /sys/module/apparmor/parameters
 * We define special types as we want to do additional mediation.
 */

/* AppArmor global enforcement switch - complain, enforce, kill */

enum profile_mode aa_g_profile_mode = APPARMOR_ENFORCE;
module_param_call(mode, param_set_mode, param_get_mode,
		  &aa_g_profile_mode, S_IRUSR | S_IWUSR);

#ifdef CONFIG_SECURITY_APPARMOR_HASH
/* whether policy verification hashing is enabled */

bool aa_g_hash_policy = IS_ENABLED(CONFIG_SECURITY_APPARMOR_HASH_DEFAULT);
module_param_named(hash_policy, aa_g_hash_policy, aabool, S_IRUSR | S_IWUSR);
#endif

/* Debug mode */

bool aa_g_debug;
module_param_named(debug, aa_g_debug, aabool, S_IRUSR | S_IWUSR);

/* Audit mode */

enum audit_mode aa_g_audit;
module_param_call(audit, param_set_audit, param_get_audit,
		  &aa_g_audit, S_IRUSR | S_IWUSR);

/* Determines if audit header is included in audited messages.  This
 * provides more context if the audit daemon is not running
 */

bool aa_g_audit_header = 1;
module_param_named(audit_header, aa_g_audit_header, aabool,
		   S_IRUSR | S_IWUSR);

/* lock out loading/removal of policy
 * TODO: add in at boot loading of policy, which is the only way to
 *       load policy, if lock_policy is set
 */

bool aa_g_lock_policy;
module_param_named(lock_policy, aa_g_lock_policy, aalockpolicy,
		   S_IRUSR | S_IWUSR);

/* Syscall logging mode */

bool aa_g_logsyscall;
module_param_named(logsyscall, aa_g_logsyscall, aabool, S_IRUSR | S_IWUSR);

/* Maximum pathname length before accesses will start getting rejected */

unsigned int aa_g_path_max = 2 * PATH_MAX;
module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR | S_IWUSR);

/* Determines how paranoid loading of policy is and how much verification
 * on the loaded policy is done.
 */

bool aa_g_paranoid_load = 1;
module_param_named(paranoid_load, aa_g_paranoid_load, aabool,
		   S_IRUSR | S_IWUSR);

/* Boot time disable flag */

static bool apparmor_enabled = CONFIG_SECURITY_APPARMOR_BOOTPARAM_VALUE;
module_param_named(enabled, apparmor_enabled, bool, S_IRUGO);



static int __init apparmor_enabled_setup(char *str)
{
	unsigned long enabled;
	int error = kstrtoul(str, 0, &enabled);
	if (!error)
		apparmor_enabled = enabled ? 1 : 0;
	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 43 97.73% 1 50.00%
jingoo han jingoo han 1 2.27% 1 50.00%
Total 44 100.00% 2 100.00%

__setup("apparmor=", apparmor_enabled_setup);

/* set global flag turning off the ability to load policy */


static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp)
{
	if (!policy_admin_capable())
		return -EPERM;
	return param_set_bool(val, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 34 97.14% 2 66.67%
stephen rothwell stephen rothwell 1 2.86% 1 33.33%
Total 35 100.00% 3 100.00%



static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp)
{
	if (!policy_view_capable())
		return -EPERM;
	return param_get_bool(buffer, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 33 97.06% 2 66.67%
stephen rothwell stephen rothwell 1 2.94% 1 33.33%
Total 34 100.00% 3 100.00%



static int param_set_aabool(const char *val, const struct kernel_param *kp)
{
	if (!policy_admin_capable())
		return -EPERM;
	return param_set_bool(val, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 34 97.14% 2 66.67%
stephen rothwell stephen rothwell 1 2.86% 1 33.33%
Total 35 100.00% 3 100.00%



static int param_get_aabool(char *buffer, const struct kernel_param *kp)
{
	if (!policy_view_capable())
		return -EPERM;
	return param_get_bool(buffer, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 33 97.06% 2 66.67%
stephen rothwell stephen rothwell 1 2.94% 1 33.33%
Total 34 100.00% 3 100.00%



static int param_set_aauint(const char *val, const struct kernel_param *kp)
{
	if (!policy_admin_capable())
		return -EPERM;
	return param_set_uint(val, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 34 97.14% 2 66.67%
stephen rothwell stephen rothwell 1 2.86% 1 33.33%
Total 35 100.00% 3 100.00%



static int param_get_aauint(char *buffer, const struct kernel_param *kp)
{
	if (!policy_view_capable())
		return -EPERM;
	return param_get_uint(buffer, kp);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 33 97.06% 2 66.67%
stephen rothwell stephen rothwell 1 2.94% 1 33.33%
Total 34 100.00% 3 100.00%



static int param_get_audit(char *buffer, struct kernel_param *kp)
{
	if (!policy_view_capable())
		return -EPERM;

	if (!apparmor_enabled)
		return -EINVAL;

	return sprintf(buffer, "%s", audit_mode_names[aa_g_audit]);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 47 100.00% 2 100.00%
Total 47 100.00% 2 100.00%



static int param_set_audit(const char *val, struct kernel_param *kp)
{
	int i;
	if (!policy_admin_capable())
		return -EPERM;

	if (!apparmor_enabled)
		return -EINVAL;

	if (!val)
		return -EINVAL;

	for (i = 0; i < AUDIT_MAX_INDEX; i++) {
		if (strcmp(val, audit_mode_names[i]) == 0) {
			aa_g_audit = i;
			return 0;
		}
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 89 100.00% 2 100.00%
Total 89 100.00% 2 100.00%



static int param_get_mode(char *buffer, struct kernel_param *kp)
{
	if (!policy_admin_capable())
		return -EPERM;

	if (!apparmor_enabled)
		return -EINVAL;

	return sprintf(buffer, "%s", aa_profile_mode_names[aa_g_profile_mode]);
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 47 100.00% 3 100.00%
Total 47 100.00% 3 100.00%



static int param_set_mode(const char *val, struct kernel_param *kp)
{
	int i;
	if (!policy_admin_capable())
		return -EPERM;

	if (!apparmor_enabled)
		return -EINVAL;

	if (!val)
		return -EINVAL;

	for (i = 0; i < APPARMOR_MODE_NAMES_MAX_INDEX; i++) {
		if (strcmp(val, aa_profile_mode_names[i]) == 0) {
			aa_g_profile_mode = i;
			return 0;
		}
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 89 100.00% 3 100.00%
Total 89 100.00% 3 100.00%

/*
 * AppArmor init functions
 */

/**
 * set_init_cxt - set a task context and profile on the first task.
 *
 * TODO: allow setting an alternate profile than unconfined
 */


static int __init set_init_cxt(void)
{
	struct cred *cred = (struct cred *)current->real_cred;
	struct aa_task_cxt *cxt;

	cxt = aa_alloc_task_context(GFP_KERNEL);
	if (!cxt)
		return -ENOMEM;

	cxt->profile = aa_get_profile(root_ns->unconfined);
	cred_cxt(cred) = cxt;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static int __init apparmor_init(void)
{
	int error;

	if (!apparmor_enabled || !security_module_enable("apparmor")) {
		aa_info_message("AppArmor disabled by boot time parameter");
		apparmor_enabled = 0;
		return 0;
	}

	error = aa_alloc_root_ns();
	if (error) {
		AA_ERROR("Unable to allocate default profile namespace\n");
		goto alloc_out;
	}

	error = set_init_cxt();
	if (error) {
		AA_ERROR("Failed to set context on init task\n");
		aa_free_root_ns();
		goto alloc_out;
	}
	security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks));

	/* Report that AppArmor successfully initialized */
	apparmor_initialized = 1;
	if (aa_g_profile_mode == APPARMOR_COMPLAIN)
		aa_info_message("AppArmor initialized: complain mode enabled");
	else if (aa_g_profile_mode == APPARMOR_KILL)
		aa_info_message("AppArmor initialized: kill mode enabled");
	else
		aa_info_message("AppArmor initialized");

	return error;

alloc_out:
	aa_destroy_aafs();

	apparmor_enabled = 0;
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 127 92.70% 2 66.67%
casey schaufler casey schaufler 10 7.30% 1 33.33%
Total 137 100.00% 3 100.00%


security_initcall(apparmor_init);
Overall Contributors
Person Tokens Prop Commits CommitProp
john johansen john johansen 3516 89.28% 12 24.49%
casey schaufler casey schaufler 148 3.76% 3 6.12%
vegard nossum vegard nossum 67 1.70% 1 2.04%
stephen rothwell stephen rothwell 63 1.60% 1 2.04%
al viro al viro 59 1.50% 16 32.65%
david howells david howells 24 0.61% 2 4.08%
eric paris eric paris 15 0.38% 4 8.16%
rusty russell rusty russell 9 0.23% 2 4.08%
arnd bergmann arnd bergmann 8 0.20% 1 2.04%
serge hallyn serge hallyn 8 0.20% 1 2.04%
steven rostedt steven rostedt 8 0.20% 1 2.04%
jiri slaby jiri slaby 5 0.13% 1 2.04%
luis r. rodriguez luis r. rodriguez 3 0.08% 1 2.04%
eric w. biederman eric w. biederman 2 0.05% 1 2.04%
jani nikula jani nikula 2 0.05% 1 2.04%
jingoo han jingoo han 1 0.03% 1 2.04%
Total 3938 100.00% 49 100.00%
Directory: security/apparmor

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
john johansen	john johansen	26	100.00%	2	100.00%
	Total	26	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 security/apparmor/lsm.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
