2019-06-01 08:08:55 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2010-07-29 21:48:07 +00:00
|
|
|
/*
|
|
|
|
* AppArmor security module
|
|
|
|
*
|
|
|
|
* This file contains AppArmor LSM hooks.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1998-2008 Novell/SUSE
|
|
|
|
* Copyright 2009-2010 Canonical Ltd.
|
|
|
|
*/
|
|
|
|
|
2015-05-02 22:10:46 +00:00
|
|
|
#include <linux/lsm_hooks.h>
|
2010-07-29 21:48:07 +00:00
|
|
|
#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>
|
userns: security: make capabilities relative to the user namespace
- Introduce ns_capable to test for a capability in a non-default
user namespace.
- Teach cap_capable to handle capabilities in a non-default
user namespace.
The motivation is to get to the unprivileged creation of new
namespaces. It looks like this gets us 90% of the way there, with
only potential uid confusion issues left.
I still need to handle getting all caps after creation but otherwise I
think I have a good starter patch that achieves all of your goals.
Changelog:
11/05/2010: [serge] add apparmor
12/14/2010: [serge] fix capabilities to created user namespaces
Without this, if user serge creates a user_ns, he won't have
capabilities to the user_ns he created. THis is because we
were first checking whether his effective caps had the caps
he needed and returning -EPERM if not, and THEN checking whether
he was the creator. Reverse those checks.
12/16/2010: [serge] security_real_capable needs ns argument in !security case
01/11/2011: [serge] add task_ns_capable helper
01/11/2011: [serge] add nsown_capable() helper per Bastian Blank suggestion
02/16/2011: [serge] fix a logic bug: the root user is always creator of
init_user_ns, but should not always have capabilities to
it! Fix the check in cap_capable().
02/21/2011: Add the required user_ns parameter to security_capable,
fixing a compile failure.
02/23/2011: Convert some macros to functions as per akpm comments. Some
couldn't be converted because we can't easily forward-declare
them (they are inline if !SECURITY, extern if SECURITY). Add
a current_user_ns function so we can use it in capability.h
without #including cred.h. Move all forward declarations
together to the top of the #ifdef __KERNEL__ section, and use
kernel-doc format.
02/23/2011: Per dhowells, clean up comment in cap_capable().
02/23/2011: Per akpm, remove unreachable 'return -EPERM' in cap_capable.
(Original written and signed off by Eric; latest, modified version
acked by him)
[akpm@linux-foundation.org: fix build]
[akpm@linux-foundation.org: export current_user_ns() for ecryptfs]
[serge.hallyn@canonical.com: remove unneeded extra argument in selinux's task_has_capability]
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Serge E. Hallyn <serge.hallyn@canonical.com>
Acked-by: "Eric W. Biederman" <ebiederm@xmission.com>
Acked-by: Daniel Lezcano <daniel.lezcano@free.fr>
Acked-by: David Howells <dhowells@redhat.com>
Cc: James Morris <jmorris@namei.org>
Signed-off-by: Serge E. Hallyn <serge.hallyn@canonical.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-03-23 23:43:17 +00:00
|
|
|
#include <linux/user_namespace.h>
|
2018-05-24 20:27:47 +00:00
|
|
|
#include <linux/netfilter_ipv4.h>
|
|
|
|
#include <linux/netfilter_ipv6.h>
|
2019-01-23 19:17:09 +00:00
|
|
|
#include <linux/zlib.h>
|
2010-07-29 21:48:07 +00:00
|
|
|
#include <net/sock.h>
|
2018-11-01 23:07:23 +00:00
|
|
|
#include <uapi/linux/mount.h>
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
#include "include/apparmor.h"
|
|
|
|
#include "include/apparmorfs.h"
|
|
|
|
#include "include/audit.h"
|
|
|
|
#include "include/capability.h"
|
2017-10-11 08:04:48 +00:00
|
|
|
#include "include/cred.h"
|
2010-07-29 21:48:07 +00:00
|
|
|
#include "include/file.h"
|
|
|
|
#include "include/ipc.h"
|
2017-07-19 06:18:33 +00:00
|
|
|
#include "include/net.h"
|
2010-07-29 21:48:07 +00:00
|
|
|
#include "include/path.h"
|
2017-06-09 15:14:28 +00:00
|
|
|
#include "include/label.h"
|
2010-07-29 21:48:07 +00:00
|
|
|
#include "include/policy.h"
|
2017-01-16 08:42:15 +00:00
|
|
|
#include "include/policy_ns.h"
|
2010-07-29 21:48:07 +00:00
|
|
|
#include "include/procattr.h"
|
apparmor: add mount mediation
Add basic mount mediation. That allows controlling based on basic
mount parameters. It does not include special mount parameters for
apparmor, super block labeling, or any triggers for apparmor namespace
parameter modifications on pivot root.
default userspace policy rules have the form of
MOUNT RULE = ( MOUNT | REMOUNT | UMOUNT )
MOUNT = [ QUALIFIERS ] 'mount' [ MOUNT CONDITIONS ] [ SOURCE FILEGLOB ]
[ '->' MOUNTPOINT FILEGLOB ]
REMOUNT = [ QUALIFIERS ] 'remount' [ MOUNT CONDITIONS ]
MOUNTPOINT FILEGLOB
UMOUNT = [ QUALIFIERS ] 'umount' [ MOUNT CONDITIONS ] MOUNTPOINT FILEGLOB
MOUNT CONDITIONS = [ ( 'fstype' | 'vfstype' ) ( '=' | 'in' )
MOUNT FSTYPE EXPRESSION ]
[ 'options' ( '=' | 'in' ) MOUNT FLAGS EXPRESSION ]
MOUNT FSTYPE EXPRESSION = ( MOUNT FSTYPE LIST | MOUNT EXPRESSION )
MOUNT FSTYPE LIST = Comma separated list of valid filesystem and
virtual filesystem types (eg ext4, debugfs, etc)
MOUNT FLAGS EXPRESSION = ( MOUNT FLAGS LIST | MOUNT EXPRESSION )
MOUNT FLAGS LIST = Comma separated list of MOUNT FLAGS.
MOUNT FLAGS = ( 'ro' | 'rw' | 'nosuid' | 'suid' | 'nodev' | 'dev' |
'noexec' | 'exec' | 'sync' | 'async' | 'remount' |
'mand' | 'nomand' | 'dirsync' | 'noatime' | 'atime' |
'nodiratime' | 'diratime' | 'bind' | 'rbind' | 'move' |
'verbose' | 'silent' | 'loud' | 'acl' | 'noacl' |
'unbindable' | 'runbindable' | 'private' | 'rprivate' |
'slave' | 'rslave' | 'shared' | 'rshared' |
'relatime' | 'norelatime' | 'iversion' | 'noiversion' |
'strictatime' | 'nouser' | 'user' )
MOUNT EXPRESSION = ( ALPHANUMERIC | AARE ) ...
PIVOT ROOT RULE = [ QUALIFIERS ] pivot_root [ oldroot=OLD PUT FILEGLOB ]
[ NEW ROOT FILEGLOB ]
SOURCE FILEGLOB = FILEGLOB
MOUNTPOINT FILEGLOB = FILEGLOB
eg.
mount,
mount /dev/foo,
mount options=ro /dev/foo -> /mnt/,
mount options in (ro,atime) /dev/foo -> /mnt/,
mount options=ro options=atime,
Signed-off-by: John Johansen <john.johansen@canonical.com>
Acked-by: Seth Arnold <seth.arnold@canonical.com>
2017-07-19 06:04:47 +00:00
|
|
|
#include "include/mount.h"
|
2017-08-01 00:36:45 +00:00
|
|
|
#include "include/secid.h"
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
/* Flag indicating whether initialization completed */
|
2017-04-06 13:55:23 +00:00
|
|
|
int apparmor_initialized;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2019-05-03 14:12:21 +00:00
|
|
|
union aa_buffer {
|
|
|
|
struct list_head list;
|
|
|
|
char buffer[1];
|
|
|
|
};
|
2017-01-16 08:43:10 +00:00
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
#define RESERVE_COUNT 2
|
|
|
|
static int reserve_count = RESERVE_COUNT;
|
|
|
|
static int buffer_count;
|
2017-01-16 08:43:10 +00:00
|
|
|
|
2019-05-03 14:12:21 +00:00
|
|
|
static LIST_HEAD(aa_global_buffers);
|
|
|
|
static DEFINE_SPINLOCK(aa_buffers_lock);
|
2017-01-16 08:43:10 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
/*
|
|
|
|
* LSM hook functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2017-01-27 11:53:53 +00:00
|
|
|
* put the associated labels
|
2010-07-29 21:48:07 +00:00
|
|
|
*/
|
|
|
|
static void apparmor_cred_free(struct cred *cred)
|
|
|
|
{
|
2017-01-27 11:53:53 +00:00
|
|
|
aa_put_label(cred_label(cred));
|
2018-09-22 00:17:59 +00:00
|
|
|
set_cred_label(cred, NULL);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate the apparmor part of blank credentials
|
|
|
|
*/
|
|
|
|
static int apparmor_cred_alloc_blank(struct cred *cred, gfp_t gfp)
|
|
|
|
{
|
2018-09-22 00:17:59 +00:00
|
|
|
set_cred_label(cred, NULL);
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-01-27 11:53:53 +00:00
|
|
|
* prepare new cred label for modification by prepare_cred block
|
2010-07-29 21:48:07 +00:00
|
|
|
*/
|
|
|
|
static int apparmor_cred_prepare(struct cred *new, const struct cred *old,
|
|
|
|
gfp_t gfp)
|
|
|
|
{
|
2018-09-22 00:17:59 +00:00
|
|
|
set_cred_label(new, aa_get_newest_label(cred_label(old)));
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* transfer the apparmor data to a blank set of creds
|
|
|
|
*/
|
|
|
|
static void apparmor_cred_transfer(struct cred *new, const struct cred *old)
|
|
|
|
{
|
2018-09-22 00:17:59 +00:00
|
|
|
set_cred_label(new, aa_get_newest_label(cred_label(old)));
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2017-01-20 09:59:25 +00:00
|
|
|
static void apparmor_task_free(struct task_struct *task)
|
|
|
|
{
|
|
|
|
|
|
|
|
aa_free_task_ctx(task_ctx(task));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_task_alloc(struct task_struct *task,
|
|
|
|
unsigned long clone_flags)
|
|
|
|
{
|
2018-09-22 00:19:37 +00:00
|
|
|
struct aa_task_ctx *new = task_ctx(task);
|
2017-01-20 09:59:25 +00:00
|
|
|
|
2017-10-08 07:43:02 +00:00
|
|
|
aa_dup_task_ctx(new, task_ctx(current));
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2017-01-20 09:59:25 +00:00
|
|
|
return 0;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_ptrace_access_check(struct task_struct *child,
|
|
|
|
unsigned int mode)
|
|
|
|
{
|
2017-06-09 21:22:14 +00:00
|
|
|
struct aa_label *tracer, *tracee;
|
|
|
|
int error;
|
|
|
|
|
2018-09-13 16:12:09 +00:00
|
|
|
tracer = __begin_current_label_crit_section();
|
2017-06-09 21:22:14 +00:00
|
|
|
tracee = aa_get_task_label(child);
|
|
|
|
error = aa_may_ptrace(tracer, tracee,
|
2018-06-07 07:45:30 +00:00
|
|
|
(mode & PTRACE_MODE_READ) ? AA_PTRACE_READ
|
|
|
|
: AA_PTRACE_TRACE);
|
2017-06-09 21:22:14 +00:00
|
|
|
aa_put_label(tracee);
|
2018-09-13 16:12:09 +00:00
|
|
|
__end_current_label_crit_section(tracer);
|
2017-06-09 21:22:14 +00:00
|
|
|
|
|
|
|
return error;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_ptrace_traceme(struct task_struct *parent)
|
|
|
|
{
|
2017-06-09 21:22:14 +00:00
|
|
|
struct aa_label *tracer, *tracee;
|
|
|
|
int error;
|
|
|
|
|
2018-09-29 01:49:26 +00:00
|
|
|
tracee = __begin_current_label_crit_section();
|
2017-06-09 21:22:14 +00:00
|
|
|
tracer = aa_get_task_label(parent);
|
|
|
|
error = aa_may_ptrace(tracer, tracee, AA_PTRACE_TRACE);
|
|
|
|
aa_put_label(tracer);
|
2018-09-29 01:49:26 +00:00
|
|
|
__end_current_label_crit_section(tracee);
|
2017-06-09 21:22:14 +00:00
|
|
|
|
|
|
|
return error;
|
2010-07-29 21:48:07 +00: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)
|
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
const struct cred *cred;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
cred = __task_cred(target);
|
2017-06-09 15:14:28 +00:00
|
|
|
label = aa_get_newest_cred_label(cred);
|
2017-06-09 21:07:02 +00:00
|
|
|
|
2015-05-02 22:11:42 +00:00
|
|
|
/*
|
|
|
|
* cap_capget is stacked ahead of this and will
|
|
|
|
* initialize effective and permitted.
|
|
|
|
*/
|
2017-06-09 21:07:02 +00:00
|
|
|
if (!unconfined(label)) {
|
|
|
|
struct aa_profile *profile;
|
|
|
|
struct label_it i;
|
|
|
|
|
|
|
|
label_for_each_confined(i, label, profile) {
|
|
|
|
if (COMPLAIN_MODE(profile))
|
|
|
|
continue;
|
|
|
|
*effective = cap_intersect(*effective,
|
|
|
|
profile->caps.allow);
|
|
|
|
*permitted = cap_intersect(*permitted,
|
|
|
|
profile->caps.allow);
|
|
|
|
}
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2017-06-09 15:14:28 +00:00
|
|
|
aa_put_label(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-03 17:25:14 +00:00
|
|
|
static int apparmor_capable(const struct cred *cred, struct user_namespace *ns,
|
2019-01-08 00:10:53 +00:00
|
|
|
int cap, unsigned int opts)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label;
|
2015-05-02 22:11:42 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
label = aa_get_newest_cred_label(cred);
|
|
|
|
if (!unconfined(label))
|
2019-01-08 00:10:53 +00:00
|
|
|
error = aa_capable(label, cap, opts);
|
2017-06-09 15:14:28 +00:00
|
|
|
aa_put_label(label);
|
2017-06-09 09:08:28 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2017-01-16 08:43:01 +00:00
|
|
|
static int common_perm(const char *op, const struct path *path, u32 mask,
|
2010-07-29 21:48:07 +00:00
|
|
|
struct path_cond *cond)
|
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
label = __begin_current_label_crit_section();
|
|
|
|
if (!unconfined(label))
|
2017-06-09 23:02:25 +00:00
|
|
|
error = aa_path_perm(op, label, path, 0, mask, cond);
|
2017-06-09 15:14:28 +00:00
|
|
|
__end_current_label_crit_section(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-01-16 08:43:07 +00:00
|
|
|
* common_perm_cond - common permission wrapper around inode cond
|
2010-07-29 21:48:07 +00:00
|
|
|
* @op: operation being checked
|
2017-01-16 08:43:07 +00:00
|
|
|
* @path: location to check (NOT NULL)
|
2010-07-29 21:48:07 +00:00
|
|
|
* @mask: requested permissions mask
|
|
|
|
*
|
|
|
|
* Returns: %0 else error code if error or permission denied
|
|
|
|
*/
|
2017-01-16 08:43:07 +00:00
|
|
|
static int common_perm_cond(const char *op, const struct path *path, u32 mask)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2021-01-21 13:19:44 +00:00
|
|
|
struct user_namespace *mnt_userns = mnt_user_ns(path->mnt);
|
|
|
|
struct path_cond cond = {
|
|
|
|
i_uid_into_mnt(mnt_userns, d_backing_inode(path->dentry)),
|
|
|
|
d_backing_inode(path->dentry)->i_mode
|
2017-01-16 08:43:07 +00:00
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2017-01-16 08:43:07 +00:00
|
|
|
if (!path_mediated_fs(path->dentry))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return common_perm(op, path, mask, &cond);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-01-16 08:43:07 +00:00
|
|
|
* common_perm_dir_dentry - common permission wrapper when path is dir, dentry
|
2010-07-29 21:48:07 +00:00
|
|
|
* @op: operation being checked
|
2017-01-16 08:43:07 +00:00
|
|
|
* @dir: directory of the dentry (NOT NULL)
|
|
|
|
* @dentry: dentry to check (NOT NULL)
|
2010-07-29 21:48:07 +00:00
|
|
|
* @mask: requested permissions mask
|
2017-01-16 08:43:07 +00:00
|
|
|
* @cond: conditional info for the permission request (NOT NULL)
|
2010-07-29 21:48:07 +00:00
|
|
|
*
|
|
|
|
* Returns: %0 else error code if error or permission denied
|
|
|
|
*/
|
2017-01-16 08:43:07 +00:00
|
|
|
static int common_perm_dir_dentry(const char *op, const struct path *dir,
|
|
|
|
struct dentry *dentry, u32 mask,
|
|
|
|
struct path_cond *cond)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:07 +00:00
|
|
|
struct path path = { .mnt = dir->mnt, .dentry = dentry };
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2017-01-16 08:43:07 +00:00
|
|
|
return common_perm(op, &path, mask, cond);
|
2010-07-29 21:48:07 +00: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
|
|
|
|
*/
|
2017-01-16 08:43:01 +00:00
|
|
|
static int common_perm_rm(const char *op, const struct path *dir,
|
2010-07-29 21:48:07 +00:00
|
|
|
struct dentry *dentry, u32 mask)
|
|
|
|
{
|
2015-03-17 22:26:22 +00:00
|
|
|
struct inode *inode = d_backing_inode(dentry);
|
2021-01-21 13:19:44 +00:00
|
|
|
struct user_namespace *mnt_userns = mnt_user_ns(dir->mnt);
|
2010-07-29 21:48:07 +00:00
|
|
|
struct path_cond cond = { };
|
|
|
|
|
2017-01-16 08:42:28 +00:00
|
|
|
if (!inode || !path_mediated_fs(dentry))
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
|
2021-01-21 13:19:44 +00:00
|
|
|
cond.uid = i_uid_into_mnt(mnt_userns, inode);
|
2010-07-29 21:48:07 +00:00
|
|
|
cond.mode = inode->i_mode;
|
|
|
|
|
|
|
|
return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2017-01-16 08:43:01 +00:00
|
|
|
static int common_perm_create(const char *op, const struct path *dir,
|
2016-03-25 19:10:04 +00:00
|
|
|
struct dentry *dentry, u32 mask, umode_t mode)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
struct path_cond cond = { current_fsuid(), mode };
|
|
|
|
|
2017-01-16 08:42:28 +00:00
|
|
|
if (!path_mediated_fs(dir->dentry))
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:13:39 +00:00
|
|
|
static int apparmor_path_unlink(const struct path *dir, struct dentry *dentry)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
return common_perm_rm(OP_UNLINK, dir, dentry, AA_MAY_DELETE);
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:21:09 +00:00
|
|
|
static int apparmor_path_mkdir(const struct path *dir, struct dentry *dentry,
|
2011-11-21 19:56:21 +00:00
|
|
|
umode_t mode)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
return common_perm_create(OP_MKDIR, dir, dentry, AA_MAY_CREATE,
|
|
|
|
S_IFDIR);
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:13:39 +00:00
|
|
|
static int apparmor_path_rmdir(const struct path *dir, struct dentry *dentry)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
return common_perm_rm(OP_RMDIR, dir, dentry, AA_MAY_DELETE);
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:21:09 +00:00
|
|
|
static int apparmor_path_mknod(const struct path *dir, struct dentry *dentry,
|
2011-11-21 19:58:38 +00:00
|
|
|
umode_t mode, unsigned int dev)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
return common_perm_create(OP_MKNOD, dir, dentry, AA_MAY_CREATE, mode);
|
|
|
|
}
|
|
|
|
|
2016-03-25 18:22:01 +00:00
|
|
|
static int apparmor_path_truncate(const struct path *path)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-05-26 22:07:22 +00:00
|
|
|
return common_perm_cond(OP_TRUNC, path, MAY_WRITE | AA_MAY_SETATTR);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2016-03-25 19:21:09 +00:00
|
|
|
static int apparmor_path_symlink(const struct path *dir, struct dentry *dentry,
|
2010-07-29 21:48:07 +00:00
|
|
|
const char *old_name)
|
|
|
|
{
|
|
|
|
return common_perm_create(OP_SYMLINK, dir, dentry, AA_MAY_CREATE,
|
|
|
|
S_IFLNK);
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:27:45 +00:00
|
|
|
static int apparmor_path_link(struct dentry *old_dentry, const struct path *new_dir,
|
2010-07-29 21:48:07 +00:00
|
|
|
struct dentry *new_dentry)
|
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-01-16 08:42:28 +00:00
|
|
|
if (!path_mediated_fs(old_dentry))
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
label = begin_current_label_crit_section();
|
|
|
|
if (!unconfined(label))
|
2017-06-09 23:06:21 +00:00
|
|
|
error = aa_path_link(label, old_dentry, new_dir, new_dentry);
|
2017-06-09 15:14:28 +00:00
|
|
|
end_current_label_crit_section(label);
|
2017-06-09 09:08:28 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-03-25 19:27:45 +00:00
|
|
|
static int apparmor_path_rename(const struct path *old_dir, struct dentry *old_dentry,
|
|
|
|
const struct path *new_dir, struct dentry *new_dentry)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-01-16 08:42:28 +00:00
|
|
|
if (!path_mediated_fs(old_dentry))
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
label = begin_current_label_crit_section();
|
|
|
|
if (!unconfined(label)) {
|
2021-01-21 13:19:44 +00:00
|
|
|
struct user_namespace *mnt_userns = mnt_user_ns(old_dir->mnt);
|
2016-12-17 01:04:13 +00:00
|
|
|
struct path old_path = { .mnt = old_dir->mnt,
|
|
|
|
.dentry = old_dentry };
|
|
|
|
struct path new_path = { .mnt = new_dir->mnt,
|
|
|
|
.dentry = new_dentry };
|
2021-01-21 13:19:44 +00:00
|
|
|
struct path_cond cond = {
|
|
|
|
i_uid_into_mnt(mnt_userns, d_backing_inode(old_dentry)),
|
|
|
|
d_backing_inode(old_dentry)->i_mode
|
2010-07-29 21:48:07 +00:00
|
|
|
};
|
|
|
|
|
2017-06-09 23:02:25 +00:00
|
|
|
error = aa_path_perm(OP_RENAME_SRC, label, &old_path, 0,
|
2017-05-26 22:07:22 +00:00
|
|
|
MAY_READ | AA_MAY_GETATTR | MAY_WRITE |
|
|
|
|
AA_MAY_SETATTR | AA_MAY_DELETE,
|
2010-07-29 21:48:07 +00:00
|
|
|
&cond);
|
|
|
|
if (!error)
|
2017-06-09 23:02:25 +00:00
|
|
|
error = aa_path_perm(OP_RENAME_DEST, label, &new_path,
|
2017-05-26 22:07:22 +00:00
|
|
|
0, MAY_WRITE | AA_MAY_SETATTR |
|
2010-07-29 21:48:07 +00:00
|
|
|
AA_MAY_CREATE, &cond);
|
|
|
|
|
|
|
|
}
|
2017-06-09 15:14:28 +00:00
|
|
|
end_current_label_crit_section(label);
|
2017-06-09 09:08:28 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-03-25 18:56:23 +00:00
|
|
|
static int apparmor_path_chmod(const struct path *path, umode_t mode)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:07 +00:00
|
|
|
return common_perm_cond(OP_CHMOD, path, AA_MAY_CHMOD);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2016-03-25 18:44:41 +00:00
|
|
|
static int apparmor_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:07 +00:00
|
|
|
return common_perm_cond(OP_CHOWN, path, AA_MAY_CHOWN);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2015-03-08 23:28:30 +00:00
|
|
|
static int apparmor_inode_getattr(const struct path *path)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-05-26 22:07:22 +00:00
|
|
|
return common_perm_cond(OP_GETATTR, path, AA_MAY_GETATTR);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2018-07-10 18:13:18 +00:00
|
|
|
static int apparmor_file_open(struct file *file)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_file_ctx *fctx = file_ctx(file);
|
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-01-16 08:42:28 +00:00
|
|
|
if (!path_mediated_fs(file->f_path.dentry))
|
2010-07-29 21:48:07 +00:00
|
|
|
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) {
|
2017-01-16 08:43:00 +00:00
|
|
|
fctx->allow = MAY_EXEC | MAY_READ | AA_EXEC_MMAP;
|
2010-07-29 21:48:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-07-10 18:13:18 +00:00
|
|
|
label = aa_get_newest_cred_label(file->f_cred);
|
2017-06-09 15:14:28 +00:00
|
|
|
if (!unconfined(label)) {
|
2021-01-21 13:19:44 +00:00
|
|
|
struct user_namespace *mnt_userns = file_mnt_user_ns(file);
|
2013-01-23 22:07:38 +00:00
|
|
|
struct inode *inode = file_inode(file);
|
2021-01-21 13:19:44 +00:00
|
|
|
struct path_cond cond = {
|
|
|
|
i_uid_into_mnt(mnt_userns, inode),
|
|
|
|
inode->i_mode
|
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2017-06-09 23:02:25 +00:00
|
|
|
error = aa_path_perm(OP_OPEN, label, &file->f_path, 0,
|
2010-07-29 21:48:07 +00:00
|
|
|
aa_map_file_to_perms(file), &cond);
|
|
|
|
/* todo cache full allowed permissions set and state */
|
2017-01-16 08:43:00 +00:00
|
|
|
fctx->allow = aa_map_file_to_perms(file);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
2017-06-09 15:14:28 +00:00
|
|
|
aa_put_label(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_file_alloc_security(struct file *file)
|
|
|
|
{
|
2018-11-12 20:02:49 +00:00
|
|
|
struct aa_file_ctx *ctx = file_ctx(file);
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label = begin_current_label_crit_section();
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-11-12 20:02:49 +00:00
|
|
|
spin_lock_init(&ctx->lock);
|
|
|
|
rcu_assign_pointer(ctx->label, aa_get_label(label));
|
|
|
|
end_current_label_crit_section(label);
|
|
|
|
return 0;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void apparmor_file_free_security(struct file *file)
|
|
|
|
{
|
2018-11-12 20:02:49 +00:00
|
|
|
struct aa_file_ctx *ctx = file_ctx(file);
|
|
|
|
|
|
|
|
if (ctx)
|
|
|
|
aa_put_label(rcu_access_pointer(ctx->label));
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
static int common_file_perm(const char *op, struct file *file, u32 mask,
|
|
|
|
bool in_atomic)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-06-09 21:59:51 +00:00
|
|
|
struct aa_label *label;
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-06-09 18:58:42 +00:00
|
|
|
/* don't reaudit files closed during inheritance */
|
|
|
|
if (file->f_path.dentry == aa_null.dentry)
|
|
|
|
return -EACCES;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
label = __begin_current_label_crit_section();
|
2019-09-14 10:34:06 +00:00
|
|
|
error = aa_file_perm(op, label, file, mask, in_atomic);
|
2017-06-09 15:14:28 +00:00
|
|
|
__end_current_label_crit_section(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-06-10 00:15:56 +00:00
|
|
|
static int apparmor_file_receive(struct file *file)
|
|
|
|
{
|
2019-09-14 10:34:06 +00:00
|
|
|
return common_file_perm(OP_FRECEIVE, file, aa_map_file_to_perms(file),
|
|
|
|
false);
|
2017-06-10 00:15:56 +00:00
|
|
|
}
|
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
static int apparmor_file_permission(struct file *file, int mask)
|
|
|
|
{
|
2019-09-14 10:34:06 +00:00
|
|
|
return common_file_perm(OP_FPERM, file, mask, false);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_file_lock(struct file *file, unsigned int cmd)
|
|
|
|
{
|
|
|
|
u32 mask = AA_MAY_LOCK;
|
|
|
|
|
|
|
|
if (cmd == F_WRLCK)
|
|
|
|
mask |= MAY_WRITE;
|
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
return common_file_perm(OP_FLOCK, file, mask, false);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2017-01-16 08:43:01 +00:00
|
|
|
static int common_mmap(const char *op, struct file *file, unsigned long prot,
|
2019-09-14 10:34:06 +00:00
|
|
|
unsigned long flags, bool in_atomic)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
int mask = 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
if (!file || !file_ctx(file))
|
2010-07-29 21:48:07 +00:00
|
|
|
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;
|
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
return common_file_perm(op, file, mask, in_atomic);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2012-05-30 17:30:51 +00:00
|
|
|
static int apparmor_mmap_file(struct file *file, unsigned long reqprot,
|
|
|
|
unsigned long prot, unsigned long flags)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2019-09-14 10:34:06 +00:00
|
|
|
return common_mmap(OP_FMMAP, file, prot, flags, GFP_ATOMIC);
|
2010-07-29 21:48:07 +00: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,
|
2019-09-14 10:34:06 +00:00
|
|
|
!(vma->vm_flags & VM_SHARED) ? MAP_PRIVATE : 0,
|
|
|
|
false);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
apparmor: add mount mediation
Add basic mount mediation. That allows controlling based on basic
mount parameters. It does not include special mount parameters for
apparmor, super block labeling, or any triggers for apparmor namespace
parameter modifications on pivot root.
default userspace policy rules have the form of
MOUNT RULE = ( MOUNT | REMOUNT | UMOUNT )
MOUNT = [ QUALIFIERS ] 'mount' [ MOUNT CONDITIONS ] [ SOURCE FILEGLOB ]
[ '->' MOUNTPOINT FILEGLOB ]
REMOUNT = [ QUALIFIERS ] 'remount' [ MOUNT CONDITIONS ]
MOUNTPOINT FILEGLOB
UMOUNT = [ QUALIFIERS ] 'umount' [ MOUNT CONDITIONS ] MOUNTPOINT FILEGLOB
MOUNT CONDITIONS = [ ( 'fstype' | 'vfstype' ) ( '=' | 'in' )
MOUNT FSTYPE EXPRESSION ]
[ 'options' ( '=' | 'in' ) MOUNT FLAGS EXPRESSION ]
MOUNT FSTYPE EXPRESSION = ( MOUNT FSTYPE LIST | MOUNT EXPRESSION )
MOUNT FSTYPE LIST = Comma separated list of valid filesystem and
virtual filesystem types (eg ext4, debugfs, etc)
MOUNT FLAGS EXPRESSION = ( MOUNT FLAGS LIST | MOUNT EXPRESSION )
MOUNT FLAGS LIST = Comma separated list of MOUNT FLAGS.
MOUNT FLAGS = ( 'ro' | 'rw' | 'nosuid' | 'suid' | 'nodev' | 'dev' |
'noexec' | 'exec' | 'sync' | 'async' | 'remount' |
'mand' | 'nomand' | 'dirsync' | 'noatime' | 'atime' |
'nodiratime' | 'diratime' | 'bind' | 'rbind' | 'move' |
'verbose' | 'silent' | 'loud' | 'acl' | 'noacl' |
'unbindable' | 'runbindable' | 'private' | 'rprivate' |
'slave' | 'rslave' | 'shared' | 'rshared' |
'relatime' | 'norelatime' | 'iversion' | 'noiversion' |
'strictatime' | 'nouser' | 'user' )
MOUNT EXPRESSION = ( ALPHANUMERIC | AARE ) ...
PIVOT ROOT RULE = [ QUALIFIERS ] pivot_root [ oldroot=OLD PUT FILEGLOB ]
[ NEW ROOT FILEGLOB ]
SOURCE FILEGLOB = FILEGLOB
MOUNTPOINT FILEGLOB = FILEGLOB
eg.
mount,
mount /dev/foo,
mount options=ro /dev/foo -> /mnt/,
mount options in (ro,atime) /dev/foo -> /mnt/,
mount options=ro options=atime,
Signed-off-by: John Johansen <john.johansen@canonical.com>
Acked-by: Seth Arnold <seth.arnold@canonical.com>
2017-07-19 06:04:47 +00:00
|
|
|
static int apparmor_sb_mount(const char *dev_name, const struct path *path,
|
|
|
|
const char *type, unsigned long flags, void *data)
|
|
|
|
{
|
|
|
|
struct aa_label *label;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
/* Discard magic */
|
|
|
|
if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
|
|
|
|
flags &= ~MS_MGC_MSK;
|
|
|
|
|
|
|
|
flags &= ~AA_MS_IGNORE_MASK;
|
|
|
|
|
|
|
|
label = __begin_current_label_crit_section();
|
|
|
|
if (!unconfined(label)) {
|
|
|
|
if (flags & MS_REMOUNT)
|
|
|
|
error = aa_remount(label, path, flags, data);
|
|
|
|
else if (flags & MS_BIND)
|
|
|
|
error = aa_bind_mount(label, path, dev_name, flags);
|
|
|
|
else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE |
|
|
|
|
MS_UNBINDABLE))
|
|
|
|
error = aa_mount_change_type(label, path, flags);
|
|
|
|
else if (flags & MS_MOVE)
|
|
|
|
error = aa_move_mount(label, path, dev_name);
|
|
|
|
else
|
|
|
|
error = aa_new_mount(label, dev_name, path, type,
|
|
|
|
flags, data);
|
|
|
|
}
|
|
|
|
__end_current_label_crit_section(label);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_sb_umount(struct vfsmount *mnt, int flags)
|
|
|
|
{
|
|
|
|
struct aa_label *label;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
label = __begin_current_label_crit_section();
|
|
|
|
if (!unconfined(label))
|
|
|
|
error = aa_umount(label, mnt, flags);
|
|
|
|
__end_current_label_crit_section(label);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int apparmor_sb_pivotroot(const struct path *old_path,
|
|
|
|
const struct path *new_path)
|
|
|
|
{
|
|
|
|
struct aa_label *label;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
label = aa_get_current_label();
|
|
|
|
if (!unconfined(label))
|
|
|
|
error = aa_pivotroot(label, old_path, new_path);
|
|
|
|
aa_put_label(label);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-07-29 21:48:07 +00: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);
|
2017-10-08 07:43:02 +00:00
|
|
|
struct aa_task_ctx *ctx = task_ctx(current);
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label = NULL;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
if (strcmp(name, "current") == 0)
|
2017-01-27 11:53:53 +00:00
|
|
|
label = aa_get_newest_label(cred_label(cred));
|
2017-01-16 08:43:00 +00:00
|
|
|
else if (strcmp(name, "prev") == 0 && ctx->previous)
|
2017-06-09 15:14:28 +00:00
|
|
|
label = aa_get_newest_label(ctx->previous);
|
2017-01-16 08:43:00 +00:00
|
|
|
else if (strcmp(name, "exec") == 0 && ctx->onexec)
|
2017-06-09 15:14:28 +00:00
|
|
|
label = aa_get_newest_label(ctx->onexec);
|
2010-07-29 21:48:07 +00:00
|
|
|
else
|
|
|
|
error = -EINVAL;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
if (label)
|
2017-06-09 19:47:17 +00:00
|
|
|
error = aa_getprocattr(label, value);
|
2013-07-11 04:07:43 +00:00
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
aa_put_label(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
put_cred(cred);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-01-09 15:07:31 +00:00
|
|
|
static int apparmor_setprocattr(const char *name, void *value,
|
|
|
|
size_t size)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2016-07-07 20:41:11 +00:00
|
|
|
char *command, *largs = NULL, *args = value;
|
2010-07-29 21:48:07 +00:00
|
|
|
size_t arg_size;
|
|
|
|
int error;
|
2017-01-16 08:43:02 +00:00
|
|
|
DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, OP_SETPROCATTR);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-07-07 20:41:11 +00:00
|
|
|
/* 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;
|
2010-07-29 21:48:07 +00:00
|
|
|
args = strim(args);
|
|
|
|
command = strsep(&args, " ");
|
|
|
|
if (!args)
|
2016-07-07 20:41:11 +00:00
|
|
|
goto out;
|
2010-07-29 21:48:07 +00:00
|
|
|
args = skip_spaces(args);
|
|
|
|
if (!*args)
|
2016-07-07 20:41:11 +00:00
|
|
|
goto out;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2016-07-10 06:46:33 +00:00
|
|
|
arg_size = size - (args - (largs ? largs : (char *) value));
|
2010-07-29 21:48:07 +00:00
|
|
|
if (strcmp(name, "current") == 0) {
|
|
|
|
if (strcmp(command, "changehat") == 0) {
|
|
|
|
error = aa_setprocattr_changehat(args, arg_size,
|
2017-06-09 18:36:48 +00:00
|
|
|
AA_CHANGE_NOFLAGS);
|
2010-07-29 21:48:07 +00:00
|
|
|
} else if (strcmp(command, "permhat") == 0) {
|
|
|
|
error = aa_setprocattr_changehat(args, arg_size,
|
2017-06-09 18:36:48 +00:00
|
|
|
AA_CHANGE_TEST);
|
2010-07-29 21:48:07 +00:00
|
|
|
} else if (strcmp(command, "changeprofile") == 0) {
|
2017-06-09 18:36:48 +00:00
|
|
|
error = aa_change_profile(args, AA_CHANGE_NOFLAGS);
|
2010-07-29 21:48:07 +00:00
|
|
|
} else if (strcmp(command, "permprofile") == 0) {
|
2017-06-09 18:36:48 +00:00
|
|
|
error = aa_change_profile(args, AA_CHANGE_TEST);
|
2017-06-10 00:22:50 +00:00
|
|
|
} else if (strcmp(command, "stack") == 0) {
|
|
|
|
error = aa_change_profile(args, AA_CHANGE_STACK);
|
2013-02-27 11:44:40 +00:00
|
|
|
} else
|
|
|
|
goto fail;
|
2010-07-29 21:48:07 +00:00
|
|
|
} else if (strcmp(name, "exec") == 0) {
|
2013-02-27 11:44:40 +00:00
|
|
|
if (strcmp(command, "exec") == 0)
|
2017-06-09 18:36:48 +00:00
|
|
|
error = aa_change_profile(args, AA_CHANGE_ONEXEC);
|
2017-06-10 00:22:50 +00:00
|
|
|
else if (strcmp(command, "stack") == 0)
|
|
|
|
error = aa_change_profile(args, (AA_CHANGE_ONEXEC |
|
|
|
|
AA_CHANGE_STACK));
|
2013-02-27 11:44:40 +00:00
|
|
|
else
|
|
|
|
goto fail;
|
|
|
|
} else
|
2010-07-29 21:48:07 +00:00
|
|
|
/* only support the "current" and "exec" process attributes */
|
2016-07-07 20:41:11 +00:00
|
|
|
goto fail;
|
2013-02-27 11:44:40 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
if (!error)
|
|
|
|
error = size;
|
2016-07-07 20:41:11 +00:00
|
|
|
out:
|
|
|
|
kfree(largs);
|
2010-07-29 21:48:07 +00:00
|
|
|
return error;
|
2013-02-27 11:44:40 +00:00
|
|
|
|
|
|
|
fail:
|
2017-06-09 15:14:28 +00:00
|
|
|
aad(&sa)->label = begin_current_label_crit_section();
|
2017-01-16 08:43:02 +00:00
|
|
|
aad(&sa)->info = name;
|
|
|
|
aad(&sa)->error = error = -EINVAL;
|
2013-02-27 11:44:40 +00:00
|
|
|
aa_audit_msg(AUDIT_APPARMOR_DENIED, &sa, NULL);
|
2017-06-09 15:14:28 +00:00
|
|
|
end_current_label_crit_section(aad(&sa)->label);
|
2016-07-07 20:41:11 +00:00
|
|
|
goto out;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2017-06-09 12:27:50 +00:00
|
|
|
/**
|
|
|
|
* apparmor_bprm_committing_creds - do task cleanup on committing new creds
|
|
|
|
* @bprm: binprm for the exec (NOT NULL)
|
|
|
|
*/
|
|
|
|
static void apparmor_bprm_committing_creds(struct linux_binprm *bprm)
|
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label = aa_current_raw_label();
|
2017-01-27 11:53:53 +00:00
|
|
|
struct aa_label *new_label = cred_label(bprm->cred);
|
2017-06-09 12:27:50 +00:00
|
|
|
|
|
|
|
/* bail out if unconfined or not changing profile */
|
2017-01-27 11:53:53 +00:00
|
|
|
if ((new_label->proxy == label->proxy) ||
|
|
|
|
(unconfined(new_label)))
|
2017-06-09 12:27:50 +00:00
|
|
|
return;
|
|
|
|
|
2017-06-09 18:58:42 +00:00
|
|
|
aa_inherit_files(bprm->cred, current->files);
|
|
|
|
|
2017-06-09 12:27:50 +00:00
|
|
|
current->pdeath_signal = 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
/* reset soft limits and set hard limits for the new label */
|
2017-01-27 11:53:53 +00:00
|
|
|
__aa_transition_rlimits(label, new_label);
|
2017-06-09 12:27:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_bprm_committed_cred - do cleanup after new creds committed
|
|
|
|
* @bprm: binprm for the exec (NOT NULL)
|
|
|
|
*/
|
|
|
|
static void apparmor_bprm_committed_creds(struct linux_binprm *bprm)
|
|
|
|
{
|
2017-01-20 09:59:25 +00:00
|
|
|
/* clear out temporary/transitional state from the context */
|
2017-10-08 07:43:02 +00:00
|
|
|
aa_clear_task_ctx_trans(task_ctx(current));
|
2017-01-20 09:59:25 +00:00
|
|
|
|
2017-06-09 12:27:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-09-11 18:29:53 +00:00
|
|
|
static void apparmor_task_getsecid(struct task_struct *p, u32 *secid)
|
|
|
|
{
|
|
|
|
struct aa_label *label = aa_get_task_label(p);
|
|
|
|
*secid = label->secid;
|
|
|
|
aa_put_label(label);
|
|
|
|
}
|
|
|
|
|
2010-08-11 09:28:02 +00:00
|
|
|
static int apparmor_task_setrlimit(struct task_struct *task,
|
|
|
|
unsigned int resource, struct rlimit *new_rlim)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-06-09 15:14:28 +00:00
|
|
|
struct aa_label *label = __begin_current_label_crit_section();
|
2010-07-29 21:48:07 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2017-06-09 15:14:28 +00:00
|
|
|
if (!unconfined(label))
|
2017-06-09 21:15:20 +00:00
|
|
|
error = aa_task_setrlimit(label, task, resource, new_rlim);
|
2017-06-09 15:14:28 +00:00
|
|
|
__end_current_label_crit_section(label);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2018-09-25 09:27:20 +00:00
|
|
|
static int apparmor_task_kill(struct task_struct *target, struct kernel_siginfo *info,
|
usb, signal, security: only pass the cred, not the secid, to kill_pid_info_as_cred and security_task_kill
commit d178bc3a708f39cbfefc3fab37032d3f2511b4ec ("user namespace: usb:
make usb urbs user namespace aware (v2)") changed kill_pid_info_as_uid
to kill_pid_info_as_cred, saving and passing a cred structure instead of
uids. Since the secid can be obtained from the cred, drop the secid fields
from the usb_dev_state and async structures, and drop the secid argument to
kill_pid_info_as_cred. Replace the secid argument to security_task_kill
with the cred. Update SELinux, Smack, and AppArmor to use the cred, which
avoids the need for Smack and AppArmor to use a secid at all in this hook.
Further changes to Smack might still be required to take full advantage of
this change, since it should now be possible to perform capability
checking based on the supplied cred. The changes to Smack and AppArmor
have only been compile-tested.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Acked-by: Paul Moore <paul@paul-moore.com>
Acked-by: Casey Schaufler <casey@schaufler-ca.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: James Morris <james.morris@microsoft.com>
2017-09-08 16:40:01 +00:00
|
|
|
int sig, const struct cred *cred)
|
2017-07-19 05:56:22 +00:00
|
|
|
{
|
|
|
|
struct aa_label *cl, *tl;
|
|
|
|
int error;
|
|
|
|
|
usb, signal, security: only pass the cred, not the secid, to kill_pid_info_as_cred and security_task_kill
commit d178bc3a708f39cbfefc3fab37032d3f2511b4ec ("user namespace: usb:
make usb urbs user namespace aware (v2)") changed kill_pid_info_as_uid
to kill_pid_info_as_cred, saving and passing a cred structure instead of
uids. Since the secid can be obtained from the cred, drop the secid fields
from the usb_dev_state and async structures, and drop the secid argument to
kill_pid_info_as_cred. Replace the secid argument to security_task_kill
with the cred. Update SELinux, Smack, and AppArmor to use the cred, which
avoids the need for Smack and AppArmor to use a secid at all in this hook.
Further changes to Smack might still be required to take full advantage of
this change, since it should now be possible to perform capability
checking based on the supplied cred. The changes to Smack and AppArmor
have only been compile-tested.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Acked-by: Paul Moore <paul@paul-moore.com>
Acked-by: Casey Schaufler <casey@schaufler-ca.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: James Morris <james.morris@microsoft.com>
2017-09-08 16:40:01 +00:00
|
|
|
if (cred) {
|
|
|
|
/*
|
|
|
|
* Dealing with USB IO specific behavior
|
2017-07-19 05:56:22 +00:00
|
|
|
*/
|
usb, signal, security: only pass the cred, not the secid, to kill_pid_info_as_cred and security_task_kill
commit d178bc3a708f39cbfefc3fab37032d3f2511b4ec ("user namespace: usb:
make usb urbs user namespace aware (v2)") changed kill_pid_info_as_uid
to kill_pid_info_as_cred, saving and passing a cred structure instead of
uids. Since the secid can be obtained from the cred, drop the secid fields
from the usb_dev_state and async structures, and drop the secid argument to
kill_pid_info_as_cred. Replace the secid argument to security_task_kill
with the cred. Update SELinux, Smack, and AppArmor to use the cred, which
avoids the need for Smack and AppArmor to use a secid at all in this hook.
Further changes to Smack might still be required to take full advantage of
this change, since it should now be possible to perform capability
checking based on the supplied cred. The changes to Smack and AppArmor
have only been compile-tested.
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Acked-by: Paul Moore <paul@paul-moore.com>
Acked-by: Casey Schaufler <casey@schaufler-ca.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: John Johansen <john.johansen@canonical.com>
Signed-off-by: James Morris <james.morris@microsoft.com>
2017-09-08 16:40:01 +00:00
|
|
|
cl = aa_get_newest_cred_label(cred);
|
|
|
|
tl = aa_get_task_label(target);
|
|
|
|
error = aa_may_signal(cl, tl, sig);
|
|
|
|
aa_put_label(cl);
|
|
|
|
aa_put_label(tl);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-07-19 05:56:22 +00:00
|
|
|
cl = __begin_current_label_crit_section();
|
|
|
|
tl = aa_get_task_label(target);
|
|
|
|
error = aa_may_signal(cl, tl, sig);
|
|
|
|
aa_put_label(tl);
|
|
|
|
__end_current_label_crit_section(cl);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-07-19 06:18:33 +00:00
|
|
|
/**
|
|
|
|
* apparmor_sk_alloc_security - allocate and attach the sk_security field
|
|
|
|
*/
|
|
|
|
static int apparmor_sk_alloc_security(struct sock *sk, int family, gfp_t flags)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx;
|
|
|
|
|
|
|
|
ctx = kzalloc(sizeof(*ctx), flags);
|
|
|
|
if (!ctx)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
SK_CTX(sk) = ctx;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_sk_free_security - free the sk_security field
|
|
|
|
*/
|
|
|
|
static void apparmor_sk_free_security(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
|
|
|
|
SK_CTX(sk) = NULL;
|
|
|
|
aa_put_label(ctx->label);
|
|
|
|
aa_put_label(ctx->peer);
|
|
|
|
kfree(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_clone_security - clone the sk_security field
|
|
|
|
*/
|
|
|
|
static void apparmor_sk_clone_security(const struct sock *sk,
|
|
|
|
struct sock *newsk)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
struct aa_sk_ctx *new = SK_CTX(newsk);
|
|
|
|
|
apparmor: check/put label on apparmor_sk_clone_security()
Currently apparmor_sk_clone_security() does not check for existing
label/peer in the 'new' struct sock; it just overwrites it, if any
(with another reference to the label of the source sock.)
static void apparmor_sk_clone_security(const struct sock *sk,
struct sock *newsk)
{
struct aa_sk_ctx *ctx = SK_CTX(sk);
struct aa_sk_ctx *new = SK_CTX(newsk);
new->label = aa_get_label(ctx->label);
new->peer = aa_get_label(ctx->peer);
}
This might leak label references, which might overflow under load.
Thus, check for and put labels, to prevent such errors.
Note this is similarly done on:
static int apparmor_socket_post_create(struct socket *sock, ...)
...
if (sock->sk) {
struct aa_sk_ctx *ctx = SK_CTX(sock->sk);
aa_put_label(ctx->label);
ctx->label = aa_get_label(label);
}
...
Context:
-------
The label reference count leak is observed if apparmor_sock_graft()
is called previously: this sets the 'ctx->label' field by getting
a reference to the current label (later overwritten, without put.)
static void apparmor_sock_graft(struct sock *sk, ...)
{
struct aa_sk_ctx *ctx = SK_CTX(sk);
if (!ctx->label)
ctx->label = aa_get_current_label();
}
And that is the case on crypto/af_alg.c:af_alg_accept():
int af_alg_accept(struct sock *sk, struct socket *newsock, ...)
...
struct sock *sk2;
...
sk2 = sk_alloc(...);
...
security_sock_graft(sk2, newsock);
security_sk_clone(sk, sk2);
...
Apparently both calls are done on their own right, especially for
other LSMs, being introduced in 2010/2014, before apparmor socket
mediation in 2017 (see commits [1,2,3,4]).
So, it looks OK there! Let's fix the reference leak in apparmor.
Test-case:
---------
Exercise that code path enough to overflow label reference count.
$ cat aa-refcnt-af_alg.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
int main() {
int sockfd;
struct sockaddr_alg sa;
/* Setup the crypto API socket */
sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
if (sockfd < 0) {
perror("socket");
return 1;
}
memset(&sa, 0, sizeof(sa));
sa.salg_family = AF_ALG;
strcpy((char *) sa.salg_type, "rng");
strcpy((char *) sa.salg_name, "stdrng");
if (bind(sockfd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
perror("bind");
return 1;
}
/* Accept a "connection" and close it; repeat. */
while (!close(accept(sockfd, NULL, 0)));
return 0;
}
$ gcc -o aa-refcnt-af_alg aa-refcnt-af_alg.c
$ ./aa-refcnt-af_alg
<a few hours later>
[ 9928.475953] refcount_t overflow at apparmor_sk_clone_security+0x37/0x70 in aa-refcnt-af_alg[1322], uid/euid: 1000/1000
...
[ 9928.507443] RIP: 0010:apparmor_sk_clone_security+0x37/0x70
...
[ 9928.514286] security_sk_clone+0x33/0x50
[ 9928.514807] af_alg_accept+0x81/0x1c0 [af_alg]
[ 9928.516091] alg_accept+0x15/0x20 [af_alg]
[ 9928.516682] SYSC_accept4+0xff/0x210
[ 9928.519609] SyS_accept+0x10/0x20
[ 9928.520190] do_syscall_64+0x73/0x130
[ 9928.520808] entry_SYSCALL_64_after_hwframe+0x3d/0xa2
Note that other messages may be seen, not just overflow, depending on
the value being incremented by kref_get(); on another run:
[ 7273.182666] refcount_t: saturated; leaking memory.
...
[ 7273.185789] refcount_t: underflow; use-after-free.
Kprobes:
-------
Using kprobe events to monitor sk -> sk_security -> label -> count (kref):
Original v5.7 (one reference leak every iteration)
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd2
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd4
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd3
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd5
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd4
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd6
Patched v5.7 (zero reference leak per iteration)
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
Commits:
-------
[1] commit 507cad355fc9 ("crypto: af_alg - Make sure sk_security is initialized on accept()ed sockets")
[2] commit 4c63f83c2c2e ("crypto: af_alg - properly label AF_ALG socket")
[3] commit 2acce6aa9f65 ("Networking") a.k.a ("crypto: af_alg - Avoid sock_graft call warning)
[4] commit 56974a6fcfef ("apparmor: add base infastructure for socket mediation")
Fixes: 56974a6fcfef ("apparmor: add base infastructure for socket mediation")
Reported-by: Brian Moyles <bmoyles@netflix.com>
Signed-off-by: Mauricio Faria de Oliveira <mfo@canonical.com>
Signed-off-by: John Johansen <john.johansen@canonical.com>
2020-06-02 21:15:16 +00:00
|
|
|
if (new->label)
|
|
|
|
aa_put_label(new->label);
|
2017-07-19 06:18:33 +00:00
|
|
|
new->label = aa_get_label(ctx->label);
|
apparmor: check/put label on apparmor_sk_clone_security()
Currently apparmor_sk_clone_security() does not check for existing
label/peer in the 'new' struct sock; it just overwrites it, if any
(with another reference to the label of the source sock.)
static void apparmor_sk_clone_security(const struct sock *sk,
struct sock *newsk)
{
struct aa_sk_ctx *ctx = SK_CTX(sk);
struct aa_sk_ctx *new = SK_CTX(newsk);
new->label = aa_get_label(ctx->label);
new->peer = aa_get_label(ctx->peer);
}
This might leak label references, which might overflow under load.
Thus, check for and put labels, to prevent such errors.
Note this is similarly done on:
static int apparmor_socket_post_create(struct socket *sock, ...)
...
if (sock->sk) {
struct aa_sk_ctx *ctx = SK_CTX(sock->sk);
aa_put_label(ctx->label);
ctx->label = aa_get_label(label);
}
...
Context:
-------
The label reference count leak is observed if apparmor_sock_graft()
is called previously: this sets the 'ctx->label' field by getting
a reference to the current label (later overwritten, without put.)
static void apparmor_sock_graft(struct sock *sk, ...)
{
struct aa_sk_ctx *ctx = SK_CTX(sk);
if (!ctx->label)
ctx->label = aa_get_current_label();
}
And that is the case on crypto/af_alg.c:af_alg_accept():
int af_alg_accept(struct sock *sk, struct socket *newsock, ...)
...
struct sock *sk2;
...
sk2 = sk_alloc(...);
...
security_sock_graft(sk2, newsock);
security_sk_clone(sk, sk2);
...
Apparently both calls are done on their own right, especially for
other LSMs, being introduced in 2010/2014, before apparmor socket
mediation in 2017 (see commits [1,2,3,4]).
So, it looks OK there! Let's fix the reference leak in apparmor.
Test-case:
---------
Exercise that code path enough to overflow label reference count.
$ cat aa-refcnt-af_alg.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
int main() {
int sockfd;
struct sockaddr_alg sa;
/* Setup the crypto API socket */
sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
if (sockfd < 0) {
perror("socket");
return 1;
}
memset(&sa, 0, sizeof(sa));
sa.salg_family = AF_ALG;
strcpy((char *) sa.salg_type, "rng");
strcpy((char *) sa.salg_name, "stdrng");
if (bind(sockfd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
perror("bind");
return 1;
}
/* Accept a "connection" and close it; repeat. */
while (!close(accept(sockfd, NULL, 0)));
return 0;
}
$ gcc -o aa-refcnt-af_alg aa-refcnt-af_alg.c
$ ./aa-refcnt-af_alg
<a few hours later>
[ 9928.475953] refcount_t overflow at apparmor_sk_clone_security+0x37/0x70 in aa-refcnt-af_alg[1322], uid/euid: 1000/1000
...
[ 9928.507443] RIP: 0010:apparmor_sk_clone_security+0x37/0x70
...
[ 9928.514286] security_sk_clone+0x33/0x50
[ 9928.514807] af_alg_accept+0x81/0x1c0 [af_alg]
[ 9928.516091] alg_accept+0x15/0x20 [af_alg]
[ 9928.516682] SYSC_accept4+0xff/0x210
[ 9928.519609] SyS_accept+0x10/0x20
[ 9928.520190] do_syscall_64+0x73/0x130
[ 9928.520808] entry_SYSCALL_64_after_hwframe+0x3d/0xa2
Note that other messages may be seen, not just overflow, depending on
the value being incremented by kref_get(); on another run:
[ 7273.182666] refcount_t: saturated; leaking memory.
...
[ 7273.185789] refcount_t: underflow; use-after-free.
Kprobes:
-------
Using kprobe events to monitor sk -> sk_security -> label -> count (kref):
Original v5.7 (one reference leak every iteration)
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd2
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd4
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd3
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd5
... (af_alg_accept+0x0/0x1c0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd4
... (af_alg_release_parent+0x0/0xd0) label=0xffff8a0f36c25eb0 label_refcnt=0x11fd6
Patched v5.7 (zero reference leak per iteration)
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
... (af_alg_accept+0x0/0x1c0) label=0xffff9ff376c25eb0 label_refcnt=0x593
... (af_alg_release_parent+0x0/0xd0) label=0xffff9ff376c25eb0 label_refcnt=0x594
Commits:
-------
[1] commit 507cad355fc9 ("crypto: af_alg - Make sure sk_security is initialized on accept()ed sockets")
[2] commit 4c63f83c2c2e ("crypto: af_alg - properly label AF_ALG socket")
[3] commit 2acce6aa9f65 ("Networking") a.k.a ("crypto: af_alg - Avoid sock_graft call warning)
[4] commit 56974a6fcfef ("apparmor: add base infastructure for socket mediation")
Fixes: 56974a6fcfef ("apparmor: add base infastructure for socket mediation")
Reported-by: Brian Moyles <bmoyles@netflix.com>
Signed-off-by: Mauricio Faria de Oliveira <mfo@canonical.com>
Signed-off-by: John Johansen <john.johansen@canonical.com>
2020-06-02 21:15:16 +00:00
|
|
|
|
|
|
|
if (new->peer)
|
|
|
|
aa_put_label(new->peer);
|
2017-07-19 06:18:33 +00:00
|
|
|
new->peer = aa_get_label(ctx->peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_create - check perms before creating a new socket
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_create(int family, int type, int protocol, int kern)
|
|
|
|
{
|
|
|
|
struct aa_label *label;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
label = begin_current_label_crit_section();
|
|
|
|
if (!(kern || unconfined(label)))
|
|
|
|
error = af_select(family,
|
|
|
|
create_perm(label, family, type, protocol),
|
|
|
|
aa_af_perm(label, OP_CREATE, AA_MAY_CREATE,
|
|
|
|
family, type, protocol));
|
|
|
|
end_current_label_crit_section(label);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_post_create - setup the per-socket security struct
|
|
|
|
*
|
|
|
|
* Note:
|
|
|
|
* - kernel sockets currently labeled unconfined but we may want to
|
|
|
|
* move to a special kernel label
|
|
|
|
* - socket may not have sk here if created with sock_create_lite or
|
|
|
|
* sock_alloc. These should be accept cases which will be handled in
|
|
|
|
* sock_graft.
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_post_create(struct socket *sock, int family,
|
|
|
|
int type, int protocol, int kern)
|
|
|
|
{
|
|
|
|
struct aa_label *label;
|
|
|
|
|
|
|
|
if (kern) {
|
|
|
|
struct aa_ns *ns = aa_get_current_ns();
|
|
|
|
|
|
|
|
label = aa_get_label(ns_unconfined(ns));
|
|
|
|
aa_put_ns(ns);
|
|
|
|
} else
|
|
|
|
label = aa_get_current_label();
|
|
|
|
|
|
|
|
if (sock->sk) {
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sock->sk);
|
|
|
|
|
|
|
|
aa_put_label(ctx->label);
|
|
|
|
ctx->label = aa_get_label(label);
|
|
|
|
}
|
|
|
|
aa_put_label(label);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_bind - check perms before bind addr to socket
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_bind(struct socket *sock,
|
|
|
|
struct sockaddr *address, int addrlen)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(!address);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
bind_perm(sock, address, addrlen),
|
|
|
|
aa_sk_perm(OP_BIND, AA_MAY_BIND, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_connect - check perms before connecting @sock to @address
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_connect(struct socket *sock,
|
|
|
|
struct sockaddr *address, int addrlen)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(!address);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
connect_perm(sock, address, addrlen),
|
|
|
|
aa_sk_perm(OP_CONNECT, AA_MAY_CONNECT, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_list - check perms before allowing listen
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_listen(struct socket *sock, int backlog)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
listen_perm(sock, backlog),
|
|
|
|
aa_sk_perm(OP_LISTEN, AA_MAY_LISTEN, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_accept - check perms before accepting a new connection.
|
|
|
|
*
|
|
|
|
* Note: while @newsock is created and has some information, the accept
|
|
|
|
* has not been done.
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_accept(struct socket *sock, struct socket *newsock)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(!newsock);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
accept_perm(sock, newsock),
|
|
|
|
aa_sk_perm(OP_ACCEPT, AA_MAY_ACCEPT, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int aa_sock_msg_perm(const char *op, u32 request, struct socket *sock,
|
|
|
|
struct msghdr *msg, int size)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(!msg);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
msg_perm(op, request, sock, msg, size),
|
|
|
|
aa_sk_perm(op, request, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_sendmsg - check perms before sending msg to another socket
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_sendmsg(struct socket *sock,
|
|
|
|
struct msghdr *msg, int size)
|
|
|
|
{
|
|
|
|
return aa_sock_msg_perm(OP_SENDMSG, AA_MAY_SEND, sock, msg, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_recvmsg - check perms before receiving a message
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_recvmsg(struct socket *sock,
|
|
|
|
struct msghdr *msg, int size, int flags)
|
|
|
|
{
|
|
|
|
return aa_sock_msg_perm(OP_RECVMSG, AA_MAY_RECEIVE, sock, msg, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* revaliation, get/set attr, shutdown */
|
|
|
|
static int aa_sock_perm(const char *op, u32 request, struct socket *sock)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
sock_perm(op, request, sock),
|
|
|
|
aa_sk_perm(op, request, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_getsockname - check perms before getting the local address
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_getsockname(struct socket *sock)
|
|
|
|
{
|
|
|
|
return aa_sock_perm(OP_GETSOCKNAME, AA_MAY_GETATTR, sock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_getpeername - check perms before getting remote address
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_getpeername(struct socket *sock)
|
|
|
|
{
|
|
|
|
return aa_sock_perm(OP_GETPEERNAME, AA_MAY_GETATTR, sock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* revaliation, get/set attr, opt */
|
|
|
|
static int aa_sock_opt_perm(const char *op, u32 request, struct socket *sock,
|
|
|
|
int level, int optname)
|
|
|
|
{
|
|
|
|
AA_BUG(!sock);
|
|
|
|
AA_BUG(!sock->sk);
|
|
|
|
AA_BUG(in_interrupt());
|
|
|
|
|
|
|
|
return af_select(sock->sk->sk_family,
|
|
|
|
opt_perm(op, request, sock, level, optname),
|
|
|
|
aa_sk_perm(op, request, sock->sk));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_getsockopt - check perms before getting socket options
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_getsockopt(struct socket *sock, int level,
|
|
|
|
int optname)
|
|
|
|
{
|
|
|
|
return aa_sock_opt_perm(OP_GETSOCKOPT, AA_MAY_GETOPT, sock,
|
|
|
|
level, optname);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_setsockopt - check perms before setting socket options
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_setsockopt(struct socket *sock, int level,
|
|
|
|
int optname)
|
|
|
|
{
|
|
|
|
return aa_sock_opt_perm(OP_SETSOCKOPT, AA_MAY_SETOPT, sock,
|
|
|
|
level, optname);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_shutdown - check perms before shutting down @sock conn
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_shutdown(struct socket *sock, int how)
|
|
|
|
{
|
|
|
|
return aa_sock_perm(OP_SHUTDOWN, AA_MAY_SHUTDOWN, sock);
|
|
|
|
}
|
|
|
|
|
2018-10-05 16:11:47 +00:00
|
|
|
#ifdef CONFIG_NETWORK_SECMARK
|
2017-07-19 06:18:33 +00:00
|
|
|
/**
|
|
|
|
* apparmor_socket_sock_recv_skb - check perms before associating skb to sk
|
|
|
|
*
|
|
|
|
* Note: can not sleep may be called with locks held
|
|
|
|
*
|
|
|
|
* dont want protocol specific in __skb_recv_datagram()
|
|
|
|
* to deny an incoming connection socket_sock_rcv_skb()
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
2018-05-24 20:27:47 +00:00
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
|
|
|
|
if (!skb->secmark)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return apparmor_secmark_check(ctx->label, OP_RECVMSG, AA_MAY_RECEIVE,
|
|
|
|
skb->secmark, sk);
|
2017-07-19 06:18:33 +00:00
|
|
|
}
|
2018-10-05 16:11:47 +00:00
|
|
|
#endif
|
2017-07-19 06:18:33 +00:00
|
|
|
|
|
|
|
|
|
|
|
static struct aa_label *sk_peer_label(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
|
|
|
|
if (ctx->peer)
|
|
|
|
return ctx->peer;
|
|
|
|
|
|
|
|
return ERR_PTR(-ENOPROTOOPT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_getpeersec_stream - get security context of peer
|
|
|
|
*
|
|
|
|
* Note: for tcp only valid if using ipsec or cipso on lan
|
|
|
|
*/
|
|
|
|
static int apparmor_socket_getpeersec_stream(struct socket *sock,
|
|
|
|
char __user *optval,
|
|
|
|
int __user *optlen,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
int slen, error = 0;
|
|
|
|
struct aa_label *label;
|
|
|
|
struct aa_label *peer;
|
|
|
|
|
|
|
|
label = begin_current_label_crit_section();
|
|
|
|
peer = sk_peer_label(sock->sk);
|
|
|
|
if (IS_ERR(peer)) {
|
|
|
|
error = PTR_ERR(peer);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
slen = aa_label_asxprint(&name, labels_ns(label), peer,
|
|
|
|
FLAG_SHOW_MODE | FLAG_VIEW_SUBNS |
|
|
|
|
FLAG_HIDDEN_UNCONFINED, GFP_KERNEL);
|
|
|
|
/* don't include terminating \0 in slen, it breaks some apps */
|
|
|
|
if (slen < 0) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
} else {
|
|
|
|
if (slen > len) {
|
|
|
|
error = -ERANGE;
|
|
|
|
} else if (copy_to_user(optval, name, slen)) {
|
|
|
|
error = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (put_user(slen, optlen))
|
|
|
|
error = -EFAULT;
|
|
|
|
out:
|
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
end_current_label_crit_section(label);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_socket_getpeersec_dgram - get security label of packet
|
|
|
|
* @sock: the peer socket
|
|
|
|
* @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 apparmor_socket_getpeersec_dgram(struct socket *sock,
|
|
|
|
struct sk_buff *skb, u32 *secid)
|
|
|
|
|
|
|
|
{
|
|
|
|
/* TODO: requires secid support */
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* apparmor_sock_graft - Initialize newly created socket
|
|
|
|
* @sk: child sock
|
|
|
|
* @parent: parent socket
|
|
|
|
*
|
|
|
|
* Note: could set off of SOCK_CTX(parent) but need to track inode and we can
|
|
|
|
* just set sk security information off of current creating process label
|
|
|
|
* Labeling of sk for accept case - probably should be sock based
|
|
|
|
* instead of task, because of the case where an implicitly labeled
|
|
|
|
* socket is shared by different tasks.
|
|
|
|
*/
|
|
|
|
static void apparmor_sock_graft(struct sock *sk, struct socket *parent)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
|
|
|
|
if (!ctx->label)
|
|
|
|
ctx->label = aa_get_current_label();
|
|
|
|
}
|
|
|
|
|
2018-10-05 16:11:47 +00:00
|
|
|
#ifdef CONFIG_NETWORK_SECMARK
|
2020-11-30 15:36:29 +00:00
|
|
|
static int apparmor_inet_conn_request(const struct sock *sk, struct sk_buff *skb,
|
2018-05-24 20:27:47 +00:00
|
|
|
struct request_sock *req)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx = SK_CTX(sk);
|
|
|
|
|
|
|
|
if (!skb->secmark)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return apparmor_secmark_check(ctx->label, OP_CONNECT, AA_MAY_CONNECT,
|
|
|
|
skb->secmark, sk);
|
|
|
|
}
|
2018-10-05 16:11:47 +00:00
|
|
|
#endif
|
2018-05-24 20:27:47 +00:00
|
|
|
|
2018-11-12 17:30:56 +00:00
|
|
|
/*
|
|
|
|
* The cred blob is a pointer to, not an instance of, an aa_task_ctx.
|
|
|
|
*/
|
|
|
|
struct lsm_blob_sizes apparmor_blob_sizes __lsm_ro_after_init = {
|
|
|
|
.lbs_cred = sizeof(struct aa_task_ctx *),
|
2018-11-12 20:02:49 +00:00
|
|
|
.lbs_file = sizeof(struct aa_file_ctx),
|
2018-09-22 00:19:37 +00:00
|
|
|
.lbs_task = sizeof(struct aa_task_ctx),
|
2018-11-12 17:30:56 +00:00
|
|
|
};
|
|
|
|
|
2017-02-14 13:18:51 +00:00
|
|
|
static struct security_hook_list apparmor_hooks[] __lsm_ro_after_init = {
|
2015-05-02 22:11:36 +00:00
|
|
|
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),
|
|
|
|
|
apparmor: add mount mediation
Add basic mount mediation. That allows controlling based on basic
mount parameters. It does not include special mount parameters for
apparmor, super block labeling, or any triggers for apparmor namespace
parameter modifications on pivot root.
default userspace policy rules have the form of
MOUNT RULE = ( MOUNT | REMOUNT | UMOUNT )
MOUNT = [ QUALIFIERS ] 'mount' [ MOUNT CONDITIONS ] [ SOURCE FILEGLOB ]
[ '->' MOUNTPOINT FILEGLOB ]
REMOUNT = [ QUALIFIERS ] 'remount' [ MOUNT CONDITIONS ]
MOUNTPOINT FILEGLOB
UMOUNT = [ QUALIFIERS ] 'umount' [ MOUNT CONDITIONS ] MOUNTPOINT FILEGLOB
MOUNT CONDITIONS = [ ( 'fstype' | 'vfstype' ) ( '=' | 'in' )
MOUNT FSTYPE EXPRESSION ]
[ 'options' ( '=' | 'in' ) MOUNT FLAGS EXPRESSION ]
MOUNT FSTYPE EXPRESSION = ( MOUNT FSTYPE LIST | MOUNT EXPRESSION )
MOUNT FSTYPE LIST = Comma separated list of valid filesystem and
virtual filesystem types (eg ext4, debugfs, etc)
MOUNT FLAGS EXPRESSION = ( MOUNT FLAGS LIST | MOUNT EXPRESSION )
MOUNT FLAGS LIST = Comma separated list of MOUNT FLAGS.
MOUNT FLAGS = ( 'ro' | 'rw' | 'nosuid' | 'suid' | 'nodev' | 'dev' |
'noexec' | 'exec' | 'sync' | 'async' | 'remount' |
'mand' | 'nomand' | 'dirsync' | 'noatime' | 'atime' |
'nodiratime' | 'diratime' | 'bind' | 'rbind' | 'move' |
'verbose' | 'silent' | 'loud' | 'acl' | 'noacl' |
'unbindable' | 'runbindable' | 'private' | 'rprivate' |
'slave' | 'rslave' | 'shared' | 'rshared' |
'relatime' | 'norelatime' | 'iversion' | 'noiversion' |
'strictatime' | 'nouser' | 'user' )
MOUNT EXPRESSION = ( ALPHANUMERIC | AARE ) ...
PIVOT ROOT RULE = [ QUALIFIERS ] pivot_root [ oldroot=OLD PUT FILEGLOB ]
[ NEW ROOT FILEGLOB ]
SOURCE FILEGLOB = FILEGLOB
MOUNTPOINT FILEGLOB = FILEGLOB
eg.
mount,
mount /dev/foo,
mount options=ro /dev/foo -> /mnt/,
mount options in (ro,atime) /dev/foo -> /mnt/,
mount options=ro options=atime,
Signed-off-by: John Johansen <john.johansen@canonical.com>
Acked-by: Seth Arnold <seth.arnold@canonical.com>
2017-07-19 06:04:47 +00:00
|
|
|
LSM_HOOK_INIT(sb_mount, apparmor_sb_mount),
|
|
|
|
LSM_HOOK_INIT(sb_umount, apparmor_sb_umount),
|
|
|
|
LSM_HOOK_INIT(sb_pivotroot, apparmor_sb_pivotroot),
|
|
|
|
|
2015-05-02 22:11:36 +00:00
|
|
|
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),
|
2017-06-10 00:15:56 +00:00
|
|
|
LSM_HOOK_INIT(file_receive, apparmor_file_receive),
|
2015-05-02 22:11:36 +00:00
|
|
|
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),
|
|
|
|
|
2017-07-19 06:18:33 +00:00
|
|
|
LSM_HOOK_INIT(sk_alloc_security, apparmor_sk_alloc_security),
|
|
|
|
LSM_HOOK_INIT(sk_free_security, apparmor_sk_free_security),
|
|
|
|
LSM_HOOK_INIT(sk_clone_security, apparmor_sk_clone_security),
|
|
|
|
|
|
|
|
LSM_HOOK_INIT(socket_create, apparmor_socket_create),
|
|
|
|
LSM_HOOK_INIT(socket_post_create, apparmor_socket_post_create),
|
|
|
|
LSM_HOOK_INIT(socket_bind, apparmor_socket_bind),
|
|
|
|
LSM_HOOK_INIT(socket_connect, apparmor_socket_connect),
|
|
|
|
LSM_HOOK_INIT(socket_listen, apparmor_socket_listen),
|
|
|
|
LSM_HOOK_INIT(socket_accept, apparmor_socket_accept),
|
|
|
|
LSM_HOOK_INIT(socket_sendmsg, apparmor_socket_sendmsg),
|
|
|
|
LSM_HOOK_INIT(socket_recvmsg, apparmor_socket_recvmsg),
|
|
|
|
LSM_HOOK_INIT(socket_getsockname, apparmor_socket_getsockname),
|
|
|
|
LSM_HOOK_INIT(socket_getpeername, apparmor_socket_getpeername),
|
|
|
|
LSM_HOOK_INIT(socket_getsockopt, apparmor_socket_getsockopt),
|
|
|
|
LSM_HOOK_INIT(socket_setsockopt, apparmor_socket_setsockopt),
|
|
|
|
LSM_HOOK_INIT(socket_shutdown, apparmor_socket_shutdown),
|
2018-10-05 16:11:47 +00:00
|
|
|
#ifdef CONFIG_NETWORK_SECMARK
|
2017-07-19 06:18:33 +00:00
|
|
|
LSM_HOOK_INIT(socket_sock_rcv_skb, apparmor_socket_sock_rcv_skb),
|
2018-10-05 16:11:47 +00:00
|
|
|
#endif
|
2017-07-19 06:18:33 +00:00
|
|
|
LSM_HOOK_INIT(socket_getpeersec_stream,
|
|
|
|
apparmor_socket_getpeersec_stream),
|
|
|
|
LSM_HOOK_INIT(socket_getpeersec_dgram,
|
|
|
|
apparmor_socket_getpeersec_dgram),
|
|
|
|
LSM_HOOK_INIT(sock_graft, apparmor_sock_graft),
|
2018-10-05 16:11:47 +00:00
|
|
|
#ifdef CONFIG_NETWORK_SECMARK
|
2018-05-24 20:27:47 +00:00
|
|
|
LSM_HOOK_INIT(inet_conn_request, apparmor_inet_conn_request),
|
2018-10-05 16:11:47 +00:00
|
|
|
#endif
|
2017-07-19 06:18:33 +00:00
|
|
|
|
2015-05-02 22:11:36 +00:00
|
|
|
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),
|
|
|
|
|
2020-03-22 20:46:24 +00:00
|
|
|
LSM_HOOK_INIT(bprm_creds_for_exec, apparmor_bprm_creds_for_exec),
|
2015-05-02 22:11:36 +00:00
|
|
|
LSM_HOOK_INIT(bprm_committing_creds, apparmor_bprm_committing_creds),
|
|
|
|
LSM_HOOK_INIT(bprm_committed_creds, apparmor_bprm_committed_creds),
|
|
|
|
|
2017-01-20 09:59:25 +00:00
|
|
|
LSM_HOOK_INIT(task_free, apparmor_task_free),
|
|
|
|
LSM_HOOK_INIT(task_alloc, apparmor_task_alloc),
|
2021-02-19 19:26:21 +00:00
|
|
|
LSM_HOOK_INIT(task_getsecid_subj, apparmor_task_getsecid),
|
|
|
|
LSM_HOOK_INIT(task_getsecid_obj, apparmor_task_getsecid),
|
2015-05-02 22:11:36 +00:00
|
|
|
LSM_HOOK_INIT(task_setrlimit, apparmor_task_setrlimit),
|
2017-07-19 05:56:22 +00:00
|
|
|
LSM_HOOK_INIT(task_kill, apparmor_task_kill),
|
2017-08-01 00:36:45 +00:00
|
|
|
|
2018-04-16 18:23:58 +00:00
|
|
|
#ifdef CONFIG_AUDIT
|
|
|
|
LSM_HOOK_INIT(audit_rule_init, aa_audit_rule_init),
|
|
|
|
LSM_HOOK_INIT(audit_rule_known, aa_audit_rule_known),
|
|
|
|
LSM_HOOK_INIT(audit_rule_match, aa_audit_rule_match),
|
|
|
|
LSM_HOOK_INIT(audit_rule_free, aa_audit_rule_free),
|
|
|
|
#endif
|
|
|
|
|
2017-08-01 00:36:45 +00:00
|
|
|
LSM_HOOK_INIT(secid_to_secctx, apparmor_secid_to_secctx),
|
|
|
|
LSM_HOOK_INIT(secctx_to_secid, apparmor_secctx_to_secid),
|
|
|
|
LSM_HOOK_INIT(release_secctx, apparmor_release_secctx),
|
2010-07-29 21:48:07 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AppArmor sysfs module parameters
|
|
|
|
*/
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
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);
|
2011-12-15 03:11:32 +00:00
|
|
|
#define param_check_aabool param_check_bool
|
2015-05-27 01:39:38 +00:00
|
|
|
static const struct kernel_param_ops param_ops_aabool = {
|
2014-08-26 20:51:23 +00:00
|
|
|
.flags = KERNEL_PARAM_OPS_FL_NOARG,
|
2010-08-02 02:00:43 +00:00
|
|
|
.set = param_set_aabool,
|
|
|
|
.get = param_get_aabool
|
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
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);
|
2011-12-15 03:11:32 +00:00
|
|
|
#define param_check_aauint param_check_uint
|
2015-05-27 01:39:38 +00:00
|
|
|
static const struct kernel_param_ops param_ops_aauint = {
|
2010-08-02 02:00:43 +00:00
|
|
|
.set = param_set_aauint,
|
|
|
|
.get = param_get_aauint
|
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2019-01-23 19:17:09 +00:00
|
|
|
static int param_set_aacompressionlevel(const char *val,
|
|
|
|
const struct kernel_param *kp);
|
|
|
|
static int param_get_aacompressionlevel(char *buffer,
|
|
|
|
const struct kernel_param *kp);
|
|
|
|
#define param_check_aacompressionlevel param_check_int
|
|
|
|
static const struct kernel_param_ops param_ops_aacompressionlevel = {
|
|
|
|
.set = param_set_aacompressionlevel,
|
|
|
|
.get = param_get_aacompressionlevel
|
|
|
|
};
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
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);
|
2011-12-15 03:11:32 +00:00
|
|
|
#define param_check_aalockpolicy param_check_bool
|
2015-05-27 01:39:38 +00:00
|
|
|
static const struct kernel_param_ops param_ops_aalockpolicy = {
|
2014-08-26 20:51:23 +00:00
|
|
|
.flags = KERNEL_PARAM_OPS_FL_NOARG,
|
2010-08-02 02:00:43 +00:00
|
|
|
.set = param_set_aalockpolicy,
|
|
|
|
.get = param_get_aalockpolicy
|
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_set_audit(const char *val, const struct kernel_param *kp);
|
|
|
|
static int param_get_audit(char *buffer, const struct kernel_param *kp);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_set_mode(const char *val, const struct kernel_param *kp);
|
|
|
|
static int param_get_mode(char *buffer, const struct kernel_param *kp);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2014-10-24 16:16:14 +00:00
|
|
|
/* whether policy verification hashing is enabled */
|
2016-07-25 17:59:07 +00:00
|
|
|
bool aa_g_hash_policy = IS_ENABLED(CONFIG_SECURITY_APPARMOR_HASH_DEFAULT);
|
2017-01-16 21:21:27 +00:00
|
|
|
#ifdef CONFIG_SECURITY_APPARMOR_HASH
|
2014-10-24 16:16:14 +00:00
|
|
|
module_param_named(hash_policy, aa_g_hash_policy, aabool, S_IRUSR | S_IWUSR);
|
2016-07-25 17:59:07 +00:00
|
|
|
#endif
|
2014-10-24 16:16:14 +00:00
|
|
|
|
2019-01-23 19:17:09 +00:00
|
|
|
/* policy loaddata compression level */
|
|
|
|
int aa_g_rawdata_compression_level = Z_DEFAULT_COMPRESSION;
|
|
|
|
module_param_named(rawdata_compression_level, aa_g_rawdata_compression_level,
|
|
|
|
aacompressionlevel, 0400);
|
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
/* Debug mode */
|
2017-04-06 13:55:20 +00:00
|
|
|
bool aa_g_debug = IS_ENABLED(CONFIG_SECURITY_APPARMOR_DEBUG_MESSAGES);
|
2010-07-29 21:48:07 +00:00
|
|
|
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
|
|
|
|
*/
|
2017-10-07 14:02:21 +00:00
|
|
|
bool aa_g_audit_header = true;
|
2010-07-29 21:48:07 +00:00
|
|
|
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
|
|
|
|
*/
|
2012-01-12 23:02:20 +00:00
|
|
|
bool aa_g_lock_policy;
|
2010-07-29 21:48:07 +00:00
|
|
|
module_param_named(lock_policy, aa_g_lock_policy, aalockpolicy,
|
|
|
|
S_IRUSR | S_IWUSR);
|
|
|
|
|
|
|
|
/* Syscall logging mode */
|
2012-01-12 23:02:20 +00:00
|
|
|
bool aa_g_logsyscall;
|
2010-07-29 21:48:07 +00:00
|
|
|
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;
|
2017-04-06 13:55:24 +00:00
|
|
|
module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
/* Determines how paranoid loading of policy is and how much verification
|
|
|
|
* on the loaded policy is done.
|
2017-01-16 08:42:37 +00:00
|
|
|
* DEPRECATED: read only as strict checking of load is always done now
|
|
|
|
* that none root users (user namespaces) can load policy.
|
2010-07-29 21:48:07 +00:00
|
|
|
*/
|
2017-10-07 14:02:21 +00:00
|
|
|
bool aa_g_paranoid_load = true;
|
2017-01-16 08:42:37 +00:00
|
|
|
module_param_named(paranoid_load, aa_g_paranoid_load, aabool, S_IRUGO);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2019-04-08 16:07:06 +00:00
|
|
|
static int param_get_aaintbool(char *buffer, const struct kernel_param *kp);
|
|
|
|
static int param_set_aaintbool(const char *val, const struct kernel_param *kp);
|
|
|
|
#define param_check_aaintbool param_check_int
|
|
|
|
static const struct kernel_param_ops param_ops_aaintbool = {
|
|
|
|
.set = param_set_aaintbool,
|
|
|
|
.get = param_get_aaintbool
|
|
|
|
};
|
2010-07-29 21:48:07 +00:00
|
|
|
/* Boot time disable flag */
|
2018-10-02 00:08:57 +00:00
|
|
|
static int apparmor_enabled __lsm_ro_after_init = 1;
|
2019-04-08 16:07:06 +00:00
|
|
|
module_param_named(enabled, apparmor_enabled, aaintbool, 0444);
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
static int __init apparmor_enabled_setup(char *str)
|
|
|
|
{
|
|
|
|
unsigned long enabled;
|
2014-02-05 06:13:14 +00:00
|
|
|
int error = kstrtoul(str, 0, &enabled);
|
2010-07-29 21:48:07 +00:00
|
|
|
if (!error)
|
|
|
|
apparmor_enabled = enabled ? 1 : 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("apparmor=", apparmor_enabled_setup);
|
|
|
|
|
|
|
|
/* set global flag turning off the ability to load policy */
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-04-06 13:55:23 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_admin_capable(NULL))
|
2010-07-29 21:48:07 +00:00
|
|
|
return -EPERM;
|
|
|
|
return param_set_bool(val, kp);
|
|
|
|
}
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:11 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
return param_get_bool(buffer, kp);
|
|
|
|
}
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_set_aabool(const char *val, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:11 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_admin_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
return param_set_bool(val, kp);
|
|
|
|
}
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_get_aabool(char *buffer, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:11 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
return param_get_bool(buffer, kp);
|
|
|
|
}
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_set_aauint(const char *val, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-03-30 12:25:23 +00:00
|
|
|
int error;
|
|
|
|
|
2017-01-16 08:43:11 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2017-03-30 12:25:23 +00:00
|
|
|
/* file is ro but enforce 2nd line check */
|
|
|
|
if (apparmor_initialized)
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2017-03-30 12:25:23 +00:00
|
|
|
|
|
|
|
error = param_set_uint(val, kp);
|
2019-05-03 14:12:21 +00:00
|
|
|
aa_g_path_max = max_t(uint32_t, aa_g_path_max, sizeof(union aa_buffer));
|
2017-03-30 12:25:23 +00:00
|
|
|
pr_info("AppArmor: buffer size set to %d bytes\n", aa_g_path_max);
|
|
|
|
|
|
|
|
return error;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2010-08-02 02:00:43 +00:00
|
|
|
static int param_get_aauint(char *buffer, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2017-01-16 08:43:11 +00:00
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
return param_get_uint(buffer, kp);
|
|
|
|
}
|
|
|
|
|
2019-04-08 16:07:06 +00:00
|
|
|
/* Can only be set before AppArmor is initialized (i.e. on boot cmdline). */
|
|
|
|
static int param_set_aaintbool(const char *val, const struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
struct kernel_param kp_local;
|
|
|
|
bool value;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (apparmor_initialized)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* Create local copy, with arg pointing to bool type. */
|
|
|
|
value = !!*((int *)kp->arg);
|
|
|
|
memcpy(&kp_local, kp, sizeof(kp_local));
|
|
|
|
kp_local.arg = &value;
|
|
|
|
|
|
|
|
error = param_set_bool(val, &kp_local);
|
|
|
|
if (!error)
|
|
|
|
*((int *)kp->arg) = *((bool *)kp_local.arg);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To avoid changing /sys/module/apparmor/parameters/enabled from Y/N to
|
|
|
|
* 1/0, this converts the "int that is actually bool" back to bool for
|
|
|
|
* display in the /sys filesystem, while keeping it "int" for the LSM
|
|
|
|
* infrastructure.
|
|
|
|
*/
|
|
|
|
static int param_get_aaintbool(char *buffer, const struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
struct kernel_param kp_local;
|
|
|
|
bool value;
|
|
|
|
|
|
|
|
/* Create local copy, with arg pointing to bool type. */
|
|
|
|
value = !!*((int *)kp->arg);
|
|
|
|
memcpy(&kp_local, kp, sizeof(kp_local));
|
|
|
|
kp_local.arg = &value;
|
|
|
|
|
|
|
|
return param_get_bool(buffer, &kp_local);
|
|
|
|
}
|
|
|
|
|
2019-01-23 19:17:09 +00:00
|
|
|
static int param_set_aacompressionlevel(const char *val,
|
|
|
|
const struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
if (apparmor_initialized)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
error = param_set_int(val, kp);
|
|
|
|
|
|
|
|
aa_g_rawdata_compression_level = clamp(aa_g_rawdata_compression_level,
|
|
|
|
Z_NO_COMPRESSION,
|
|
|
|
Z_BEST_COMPRESSION);
|
|
|
|
pr_info("AppArmor: policy rawdata compression level set to %u\n",
|
|
|
|
aa_g_rawdata_compression_level);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int param_get_aacompressionlevel(char *buffer,
|
|
|
|
const struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2019-01-23 19:17:09 +00:00
|
|
|
return -EPERM;
|
|
|
|
return param_get_int(buffer, kp);
|
|
|
|
}
|
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_get_audit(char *buffer, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
return sprintf(buffer, "%s", audit_mode_names[aa_g_audit]);
|
|
|
|
}
|
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_set_audit(const char *val, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!val)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_admin_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-05-07 13:39:03 +00:00
|
|
|
i = match_string(audit_mode_names, AUDIT_MAX_INDEX, val);
|
|
|
|
if (i < 0)
|
|
|
|
return -EINVAL;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-05-07 13:39:03 +00:00
|
|
|
aa_g_audit = i;
|
|
|
|
return 0;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_get_mode(char *buffer, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2013-07-11 04:13:43 +00:00
|
|
|
return sprintf(buffer, "%s", aa_profile_mode_names[aa_g_profile_mode]);
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
treewide: Fix function prototypes for module_param_call()
Several function prototypes for the set/get functions defined by
module_param_call() have a slightly wrong argument types. This fixes
those in an effort to clean up the calls when running under type-enforced
compiler instrumentation for CFI. This is the result of running the
following semantic patch:
@match_module_param_call_function@
declarer name module_param_call;
identifier _name, _set_func, _get_func;
expression _arg, _mode;
@@
module_param_call(_name, _set_func, _get_func, _arg, _mode);
@fix_set_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._set_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _set_func(
-_val_type _val
+const char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
@fix_get_prototype
depends on match_module_param_call_function@
identifier match_module_param_call_function._get_func;
identifier _val, _param;
type _val_type, _param_type;
@@
int _get_func(
-_val_type _val
+char * _val
,
-_param_type _param
+const struct kernel_param * _param
) { ... }
Two additional by-hand changes are included for places where the above
Coccinelle script didn't notice them:
drivers/platform/x86/thinkpad_acpi.c
fs/lockd/svc.c
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Jessica Yu <jeyu@kernel.org>
2017-10-18 02:04:42 +00:00
|
|
|
static int param_set_mode(const char *val, const struct kernel_param *kp)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!val)
|
|
|
|
return -EINVAL;
|
2020-07-01 00:00:11 +00:00
|
|
|
if (apparmor_initialized && !aa_current_policy_admin_capable(NULL))
|
2017-04-06 13:55:23 +00:00
|
|
|
return -EPERM;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-05-07 13:39:03 +00:00
|
|
|
i = match_string(aa_profile_mode_names, APPARMOR_MODE_NAMES_MAX_INDEX,
|
|
|
|
val);
|
|
|
|
if (i < 0)
|
|
|
|
return -EINVAL;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-05-07 13:39:03 +00:00
|
|
|
aa_g_profile_mode = i;
|
|
|
|
return 0;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
char *aa_get_buffer(bool in_atomic)
|
2019-05-03 14:12:21 +00:00
|
|
|
{
|
|
|
|
union aa_buffer *aa_buf;
|
|
|
|
bool try_again = true;
|
2019-09-14 10:34:06 +00:00
|
|
|
gfp_t flags = (GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
|
2019-05-03 14:12:21 +00:00
|
|
|
|
|
|
|
retry:
|
|
|
|
spin_lock(&aa_buffers_lock);
|
2019-09-14 10:34:06 +00:00
|
|
|
if (buffer_count > reserve_count ||
|
|
|
|
(in_atomic && !list_empty(&aa_global_buffers))) {
|
2019-05-03 14:12:21 +00:00
|
|
|
aa_buf = list_first_entry(&aa_global_buffers, union aa_buffer,
|
|
|
|
list);
|
|
|
|
list_del(&aa_buf->list);
|
2019-09-14 10:34:06 +00:00
|
|
|
buffer_count--;
|
2019-05-03 14:12:21 +00:00
|
|
|
spin_unlock(&aa_buffers_lock);
|
|
|
|
return &aa_buf->buffer[0];
|
|
|
|
}
|
2019-09-14 10:34:06 +00:00
|
|
|
if (in_atomic) {
|
|
|
|
/*
|
|
|
|
* out of reserve buffers and in atomic context so increase
|
|
|
|
* how many buffers to keep in reserve
|
|
|
|
*/
|
|
|
|
reserve_count++;
|
|
|
|
flags = GFP_ATOMIC;
|
|
|
|
}
|
2019-05-03 14:12:21 +00:00
|
|
|
spin_unlock(&aa_buffers_lock);
|
|
|
|
|
2019-09-14 10:34:06 +00:00
|
|
|
if (!in_atomic)
|
|
|
|
might_sleep();
|
|
|
|
aa_buf = kmalloc(aa_g_path_max, flags);
|
2019-05-03 14:12:21 +00:00
|
|
|
if (!aa_buf) {
|
|
|
|
if (try_again) {
|
|
|
|
try_again = false;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
pr_warn_once("AppArmor: Failed to allocate a memory buffer.\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return &aa_buf->buffer[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
void aa_put_buffer(char *buf)
|
|
|
|
{
|
|
|
|
union aa_buffer *aa_buf;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
aa_buf = container_of(buf, union aa_buffer, buffer[0]);
|
|
|
|
|
|
|
|
spin_lock(&aa_buffers_lock);
|
|
|
|
list_add(&aa_buf->list, &aa_global_buffers);
|
2019-09-14 10:34:06 +00:00
|
|
|
buffer_count++;
|
2019-05-03 14:12:21 +00:00
|
|
|
spin_unlock(&aa_buffers_lock);
|
|
|
|
}
|
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
/*
|
|
|
|
* AppArmor init functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2017-01-16 08:43:00 +00:00
|
|
|
* set_init_ctx - set a task context and profile on the first task.
|
2010-07-29 21:48:07 +00:00
|
|
|
*
|
|
|
|
* TODO: allow setting an alternate profile than unconfined
|
|
|
|
*/
|
2017-01-16 08:43:00 +00:00
|
|
|
static int __init set_init_ctx(void)
|
2010-07-29 21:48:07 +00:00
|
|
|
{
|
2019-04-23 16:53:00 +00:00
|
|
|
struct cred *cred = (__force struct cred *)current->real_cred;
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2018-09-22 00:17:59 +00:00
|
|
|
set_cred_label(cred, aa_get_label(ns_unconfined(root_ns)));
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-16 08:43:10 +00:00
|
|
|
static void destroy_buffers(void)
|
|
|
|
{
|
2019-05-03 14:12:21 +00:00
|
|
|
union aa_buffer *aa_buf;
|
2017-01-16 08:43:10 +00:00
|
|
|
|
2019-05-03 14:12:21 +00:00
|
|
|
spin_lock(&aa_buffers_lock);
|
|
|
|
while (!list_empty(&aa_global_buffers)) {
|
|
|
|
aa_buf = list_first_entry(&aa_global_buffers, union aa_buffer,
|
|
|
|
list);
|
|
|
|
list_del(&aa_buf->list);
|
|
|
|
spin_unlock(&aa_buffers_lock);
|
|
|
|
kfree(aa_buf);
|
|
|
|
spin_lock(&aa_buffers_lock);
|
2017-01-16 08:43:10 +00:00
|
|
|
}
|
2019-05-03 14:12:21 +00:00
|
|
|
spin_unlock(&aa_buffers_lock);
|
2017-01-16 08:43:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init alloc_buffers(void)
|
|
|
|
{
|
2019-05-03 14:12:21 +00:00
|
|
|
union aa_buffer *aa_buf;
|
|
|
|
int i, num;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A function may require two buffers at once. Usually the buffers are
|
|
|
|
* used for a short period of time and are shared. On UP kernel buffers
|
|
|
|
* two should be enough, with more CPUs it is possible that more
|
|
|
|
* buffers will be used simultaneously. The preallocated pool may grow.
|
|
|
|
* This preallocation has also the side-effect that AppArmor will be
|
|
|
|
* disabled early at boot if aa_g_path_max is extremly high.
|
|
|
|
*/
|
|
|
|
if (num_online_cpus() > 1)
|
2019-09-14 10:34:06 +00:00
|
|
|
num = 4 + RESERVE_COUNT;
|
2019-05-03 14:12:21 +00:00
|
|
|
else
|
2019-09-14 10:34:06 +00:00
|
|
|
num = 2 + RESERVE_COUNT;
|
2019-05-03 14:12:21 +00:00
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
|
|
|
|
aa_buf = kmalloc(aa_g_path_max, GFP_KERNEL |
|
|
|
|
__GFP_RETRY_MAYFAIL | __GFP_NOWARN);
|
|
|
|
if (!aa_buf) {
|
|
|
|
destroy_buffers();
|
|
|
|
return -ENOMEM;
|
2017-01-16 08:43:10 +00:00
|
|
|
}
|
2019-05-03 14:12:21 +00:00
|
|
|
aa_put_buffer(&aa_buf->buffer[0]);
|
2017-01-16 08:43:10 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-17 00:19:10 +00:00
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
static int apparmor_dointvec(struct ctl_table *table, int write,
|
2020-04-24 06:43:38 +00:00
|
|
|
void *buffer, size_t *lenp, loff_t *ppos)
|
2016-03-17 00:19:10 +00:00
|
|
|
{
|
2020-07-01 00:00:11 +00:00
|
|
|
if (!aa_current_policy_admin_capable(NULL))
|
2016-03-17 00:19:10 +00:00
|
|
|
return -EPERM;
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return proc_dointvec(table, write, buffer, lenp, ppos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ctl_path apparmor_sysctl_path[] = {
|
|
|
|
{ .procname = "kernel", },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct ctl_table apparmor_sysctl_table[] = {
|
|
|
|
{
|
|
|
|
.procname = "unprivileged_userns_apparmor_policy",
|
|
|
|
.data = &unprivileged_userns_apparmor_policy,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0600,
|
|
|
|
.proc_handler = apparmor_dointvec,
|
|
|
|
},
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init apparmor_init_sysctl(void)
|
|
|
|
{
|
|
|
|
return register_sysctl_paths(apparmor_sysctl_path,
|
|
|
|
apparmor_sysctl_table) ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline int apparmor_init_sysctl(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SYSCTL */
|
|
|
|
|
2018-10-05 16:11:47 +00:00
|
|
|
#if defined(CONFIG_NETFILTER) && defined(CONFIG_NETWORK_SECMARK)
|
2018-05-24 20:27:47 +00:00
|
|
|
static unsigned int apparmor_ip_postroute(void *priv,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
const struct nf_hook_state *state)
|
|
|
|
{
|
|
|
|
struct aa_sk_ctx *ctx;
|
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
if (!skb->secmark)
|
|
|
|
return NF_ACCEPT;
|
|
|
|
|
|
|
|
sk = skb_to_full_sk(skb);
|
|
|
|
if (sk == NULL)
|
|
|
|
return NF_ACCEPT;
|
|
|
|
|
|
|
|
ctx = SK_CTX(sk);
|
|
|
|
if (!apparmor_secmark_check(ctx->label, OP_SENDMSG, AA_MAY_SEND,
|
|
|
|
skb->secmark, sk))
|
|
|
|
return NF_ACCEPT;
|
|
|
|
|
|
|
|
return NF_DROP_ERR(-ECONNREFUSED);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nf_hook_ops apparmor_nf_ops[] = {
|
|
|
|
{
|
2021-10-11 14:38:54 +00:00
|
|
|
.hook = apparmor_ip_postroute,
|
2018-05-24 20:27:47 +00:00
|
|
|
.pf = NFPROTO_IPV4,
|
|
|
|
.hooknum = NF_INET_POST_ROUTING,
|
|
|
|
.priority = NF_IP_PRI_SELINUX_FIRST,
|
|
|
|
},
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
{
|
2021-10-11 14:38:54 +00:00
|
|
|
.hook = apparmor_ip_postroute,
|
2018-05-24 20:27:47 +00:00
|
|
|
.pf = NFPROTO_IPV6,
|
|
|
|
.hooknum = NF_INET_POST_ROUTING,
|
|
|
|
.priority = NF_IP6_PRI_SELINUX_FIRST,
|
|
|
|
},
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __net_init apparmor_nf_register(struct net *net)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = nf_register_net_hooks(net, apparmor_nf_ops,
|
|
|
|
ARRAY_SIZE(apparmor_nf_ops));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit apparmor_nf_unregister(struct net *net)
|
|
|
|
{
|
|
|
|
nf_unregister_net_hooks(net, apparmor_nf_ops,
|
|
|
|
ARRAY_SIZE(apparmor_nf_ops));
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations apparmor_net_ops = {
|
|
|
|
.init = apparmor_nf_register,
|
|
|
|
.exit = apparmor_nf_unregister,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init apparmor_nf_ip_init(void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!apparmor_enabled)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = register_pernet_subsys(&apparmor_net_ops);
|
|
|
|
if (err)
|
|
|
|
panic("Apparmor: register_pernet_subsys: error %d\n", err);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
__initcall(apparmor_nf_ip_init);
|
2018-10-05 16:11:47 +00:00
|
|
|
#endif
|
2018-05-24 20:27:47 +00:00
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
static int __init apparmor_init(void)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2018-06-05 02:44:59 +00:00
|
|
|
aa_secids_init();
|
|
|
|
|
2017-01-16 08:42:42 +00:00
|
|
|
error = aa_setup_dfa_engine();
|
|
|
|
if (error) {
|
|
|
|
AA_ERROR("Unable to setup dfa engine\n");
|
|
|
|
goto alloc_out;
|
|
|
|
}
|
|
|
|
|
2010-07-29 21:48:07 +00:00
|
|
|
error = aa_alloc_root_ns();
|
|
|
|
if (error) {
|
|
|
|
AA_ERROR("Unable to allocate default profile namespace\n");
|
|
|
|
goto alloc_out;
|
|
|
|
}
|
|
|
|
|
2016-03-17 00:19:10 +00:00
|
|
|
error = apparmor_init_sysctl();
|
|
|
|
if (error) {
|
|
|
|
AA_ERROR("Unable to register sysctls\n");
|
|
|
|
goto alloc_out;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-16 08:43:10 +00:00
|
|
|
error = alloc_buffers();
|
|
|
|
if (error) {
|
|
|
|
AA_ERROR("Unable to allocate work buffers\n");
|
2019-05-03 14:12:21 +00:00
|
|
|
goto alloc_out;
|
2017-01-16 08:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-01-16 08:43:00 +00:00
|
|
|
error = set_init_ctx();
|
2010-07-29 21:48:07 +00:00
|
|
|
if (error) {
|
|
|
|
AA_ERROR("Failed to set context on init task\n");
|
2015-05-02 22:11:42 +00:00
|
|
|
aa_free_root_ns();
|
2017-01-16 08:43:10 +00:00
|
|
|
goto buffers_out;
|
2010-07-29 21:48:07 +00:00
|
|
|
}
|
2017-01-19 01:09:05 +00:00
|
|
|
security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks),
|
|
|
|
"apparmor");
|
2010-07-29 21:48:07 +00:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2017-01-16 08:43:10 +00:00
|
|
|
buffers_out:
|
|
|
|
destroy_buffers();
|
2010-07-29 21:48:07 +00:00
|
|
|
alloc_out:
|
|
|
|
aa_destroy_aafs();
|
2017-01-16 08:42:42 +00:00
|
|
|
aa_teardown_dfa_engine();
|
2010-07-29 21:48:07 +00:00
|
|
|
|
2017-10-07 14:02:21 +00:00
|
|
|
apparmor_enabled = false;
|
2010-07-29 21:48:07 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2018-10-11 00:18:23 +00:00
|
|
|
DEFINE_LSM(apparmor) = {
|
2018-10-11 00:18:24 +00:00
|
|
|
.name = "apparmor",
|
2018-09-20 02:57:06 +00:00
|
|
|
.flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE,
|
2018-09-14 05:28:48 +00:00
|
|
|
.enabled = &apparmor_enabled,
|
2018-11-12 17:30:56 +00:00
|
|
|
.blobs = &apparmor_blob_sizes,
|
2018-10-11 00:18:23 +00:00
|
|
|
.init = apparmor_init,
|
|
|
|
};
|