2005-04-29 17:23:29 +02:00
|
|
|
/* auditsc.c -- System-call auditing support
|
2005-04-17 00:20:36 +02:00
|
|
|
* Handles all system-call specific auditing features.
|
|
|
|
*
|
|
|
|
* Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
|
2005-11-03 17:00:25 +01:00
|
|
|
* Copyright 2005 Hewlett-Packard Development Company, L.P.
|
2006-05-24 23:09:55 +02:00
|
|
|
* Copyright (C) 2005, 2006 IBM Corporation
|
2005-04-17 00:20:36 +02:00
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
* Written by Rickard E. (Rik) Faith <faith@redhat.com>
|
|
|
|
*
|
|
|
|
* Many of the ideas implemented here are from Stephen C. Tweedie,
|
|
|
|
* especially the idea of avoiding a copy by using getname.
|
|
|
|
*
|
|
|
|
* The method for actual interception of syscall entry and exit (not in
|
|
|
|
* this file -- see entry.S) is based on a GPL'd patch written by
|
|
|
|
* okir@suse.de and Copyright 2003 SuSE Linux AG.
|
|
|
|
*
|
2006-05-24 23:09:55 +02:00
|
|
|
* POSIX message queue support added by George Wilson <ltcgcw@us.ibm.com>,
|
|
|
|
* 2006.
|
|
|
|
*
|
[PATCH] Filter rule comparators
Currently, audit only supports the "=" and "!=" operators in the -F
filter rules.
This patch reworks the support for "=" and "!=", and adds support
for ">", ">=", "<", and "<=".
This turned out to be a pretty clean, and simply process. I ended up
using the high order bits of the "field", as suggested by Steve and Amy.
This allowed for no changes whatsoever to the netlink communications.
See the documentation within the patch in the include/linux/audit.h
area, where there is a table that explains the reasoning of the bitmask
assignments clearly.
The patch adds a new function, audit_comparator(left, op, right).
This function will perform the specified comparison (op, which defaults
to "==" for backward compatibility) between two values (left and right).
If the negate bit is on, it will negate whatever that result was. This
value is returned.
Signed-off-by: Dustin Kirkland <dustin.kirkland@us.ibm.com>
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
2005-11-03 16:41:46 +01:00
|
|
|
* The support of additional filter rules compares (>, <, >=, <=) was
|
|
|
|
* added by Dustin Kirkland <dustin.kirkland@us.ibm.com>, 2005.
|
|
|
|
*
|
2005-11-03 17:00:25 +01:00
|
|
|
* Modified by Amy Griffis <amy.griffis@hp.com> to collect additional
|
|
|
|
* filesystem information.
|
2005-11-03 18:15:16 +01:00
|
|
|
*
|
|
|
|
* Subject and object context labeling support added by <danjones@us.ibm.com>
|
|
|
|
* and <dustin.kirkland@us.ibm.com> for LSPP certification compliance.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/types.h>
|
2011-07-27 01:09:06 +02:00
|
|
|
#include <linux/atomic.h>
|
2005-11-03 17:00:25 +01:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/namei.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/mm.h>
|
2011-05-23 20:51:41 +02:00
|
|
|
#include <linux/export.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2005-05-21 01:15:52 +02:00
|
|
|
#include <linux/mount.h>
|
2005-05-17 13:08:48 +02:00
|
|
|
#include <linux/socket.h>
|
2006-05-24 23:09:55 +02:00
|
|
|
#include <linux/mqueue.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/audit.h>
|
|
|
|
#include <linux/personality.h>
|
|
|
|
#include <linux/time.h>
|
2005-06-24 15:14:05 +02:00
|
|
|
#include <linux/netlink.h>
|
2005-07-13 23:47:07 +02:00
|
|
|
#include <linux/compiler.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/unistd.h>
|
2005-11-03 18:15:16 +01:00
|
|
|
#include <linux/security.h>
|
2005-12-15 19:33:52 +01:00
|
|
|
#include <linux/list.h>
|
2006-01-01 20:07:00 +01:00
|
|
|
#include <linux/tty.h>
|
2006-04-26 20:04:08 +02:00
|
|
|
#include <linux/binfmts.h>
|
2006-10-19 22:08:53 +02:00
|
|
|
#include <linux/highmem.h>
|
2006-05-06 14:22:52 +02:00
|
|
|
#include <linux/syscalls.h>
|
2008-11-11 11:48:14 +01:00
|
|
|
#include <linux/capability.h>
|
2009-03-30 01:50:06 +02:00
|
|
|
#include <linux/fs_struct.h>
|
2012-04-12 23:47:58 +02:00
|
|
|
#include <linux/compat.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-12-15 19:33:52 +01:00
|
|
|
#include "audit.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-01-03 20:23:06 +01:00
|
|
|
/* flags stating the success for a syscall */
|
|
|
|
#define AUDITSC_INVALID 0
|
|
|
|
#define AUDITSC_SUCCESS 1
|
|
|
|
#define AUDITSC_FAILURE 2
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* AUDIT_NAMES is the number of slots we reserve in the audit_context
|
2012-01-03 20:23:05 +01:00
|
|
|
* for saving names from getname(). If we get more names we will allocate
|
|
|
|
* a name dynamically and also add those to the list anchored by names_list. */
|
|
|
|
#define AUDIT_NAMES 5
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-06-09 05:19:31 +02:00
|
|
|
/* Indicates that audit should log the full pathname. */
|
|
|
|
#define AUDIT_NAME_FULL -1
|
|
|
|
|
2008-01-07 20:31:58 +01:00
|
|
|
/* no execve audit message should be longer than this (userspace limits) */
|
|
|
|
#define MAX_EXECVE_AUDIT_LEN 7500
|
|
|
|
|
2006-07-10 14:29:24 +02:00
|
|
|
/* number of audit rules */
|
|
|
|
int audit_n_rules;
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
/* determines whether we collect data for signals sent */
|
|
|
|
int audit_signals;
|
|
|
|
|
2008-11-11 11:48:14 +01:00
|
|
|
struct audit_cap_data {
|
|
|
|
kernel_cap_t permitted;
|
|
|
|
kernel_cap_t inheritable;
|
|
|
|
union {
|
|
|
|
unsigned int fE; /* effective bit of a file capability */
|
|
|
|
kernel_cap_t effective; /* effective set of a process */
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* When fs/namei.c:getname() is called, we store the pointer in name and
|
|
|
|
* we don't let putname() free it (instead we free all of the saved
|
|
|
|
* pointers at syscall exit time).
|
|
|
|
*
|
|
|
|
* Further, in fs/namei.c:path_lookup() we store the inode and device. */
|
|
|
|
struct audit_names {
|
2012-01-03 20:23:05 +01:00
|
|
|
struct list_head list; /* audit_context->names_list */
|
2005-04-17 00:20:36 +02:00
|
|
|
const char *name;
|
|
|
|
unsigned long ino;
|
|
|
|
dev_t dev;
|
|
|
|
umode_t mode;
|
2012-09-11 11:18:08 +02:00
|
|
|
kuid_t uid;
|
|
|
|
kgid_t gid;
|
2005-04-17 00:20:36 +02:00
|
|
|
dev_t rdev;
|
2006-04-03 20:06:13 +02:00
|
|
|
u32 osid;
|
2008-11-11 11:48:14 +01:00
|
|
|
struct audit_cap_data fcap;
|
|
|
|
unsigned int fcap_ver;
|
2012-01-03 20:23:05 +01:00
|
|
|
int name_len; /* number of name's characters to log */
|
|
|
|
bool name_put; /* call __putname() for this name */
|
|
|
|
/*
|
|
|
|
* This was an allocated audit_names and not from the array of
|
|
|
|
* names allocated in the task audit context. Thus this name
|
|
|
|
* should be freed on syscall exit
|
|
|
|
*/
|
|
|
|
bool should_free;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct audit_aux_data {
|
|
|
|
struct audit_aux_data *next;
|
|
|
|
int type;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define AUDIT_AUX_IPCPERM 0
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
/* Number of target pids per aux struct. */
|
|
|
|
#define AUDIT_AUX_PIDS 16
|
|
|
|
|
2006-04-26 20:04:08 +02:00
|
|
|
struct audit_aux_data_execve {
|
|
|
|
struct audit_aux_data d;
|
|
|
|
int argc;
|
|
|
|
int envc;
|
2007-07-19 10:48:15 +02:00
|
|
|
struct mm_struct *mm;
|
2006-04-26 20:04:08 +02:00
|
|
|
};
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
struct audit_aux_data_pids {
|
|
|
|
struct audit_aux_data d;
|
|
|
|
pid_t target_pid[AUDIT_AUX_PIDS];
|
2012-09-11 07:39:43 +02:00
|
|
|
kuid_t target_auid[AUDIT_AUX_PIDS];
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t target_uid[AUDIT_AUX_PIDS];
|
2008-01-08 16:06:53 +01:00
|
|
|
unsigned int target_sessionid[AUDIT_AUX_PIDS];
|
2007-03-30 00:01:04 +02:00
|
|
|
u32 target_sid[AUDIT_AUX_PIDS];
|
2008-01-07 19:40:17 +01:00
|
|
|
char target_comm[AUDIT_AUX_PIDS][TASK_COMM_LEN];
|
2007-03-30 00:01:04 +02:00
|
|
|
int pid_count;
|
|
|
|
};
|
|
|
|
|
2008-11-11 11:48:18 +01:00
|
|
|
struct audit_aux_data_bprm_fcaps {
|
|
|
|
struct audit_aux_data d;
|
|
|
|
struct audit_cap_data fcap;
|
|
|
|
unsigned int fcap_ver;
|
|
|
|
struct audit_cap_data old_pcap;
|
|
|
|
struct audit_cap_data new_pcap;
|
|
|
|
};
|
|
|
|
|
2008-11-11 11:48:22 +01:00
|
|
|
struct audit_aux_data_capset {
|
|
|
|
struct audit_aux_data d;
|
|
|
|
pid_t pid;
|
|
|
|
struct audit_cap_data cap;
|
|
|
|
};
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
struct audit_tree_refs {
|
|
|
|
struct audit_tree_refs *next;
|
|
|
|
struct audit_chunk *c[31];
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* The per-task audit context. */
|
|
|
|
struct audit_context {
|
2006-08-03 16:59:26 +02:00
|
|
|
int dummy; /* must be the first element */
|
2005-04-17 00:20:36 +02:00
|
|
|
int in_syscall; /* 1 if task is in a syscall */
|
2008-12-15 05:45:27 +01:00
|
|
|
enum audit_state state, current_state;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int serial; /* serial number for record */
|
|
|
|
int major; /* syscall number */
|
2009-08-07 22:54:29 +02:00
|
|
|
struct timespec ctime; /* time of syscall entry */
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long argv[4]; /* syscall arguments */
|
2005-04-29 17:08:28 +02:00
|
|
|
long return_code;/* syscall return code */
|
2008-12-15 05:45:27 +01:00
|
|
|
u64 prio;
|
2009-08-07 22:54:29 +02:00
|
|
|
int return_valid; /* return code is valid */
|
2012-01-03 20:23:05 +01:00
|
|
|
/*
|
|
|
|
* The names_list is the list of all audit_names collected during this
|
|
|
|
* syscall. The first AUDIT_NAMES entries in the names_list will
|
|
|
|
* actually be from the preallocated_names array for performance
|
|
|
|
* reasons. Except during allocation they should never be referenced
|
|
|
|
* through the preallocated_names array and should only be found/used
|
|
|
|
* by running the names_list.
|
|
|
|
*/
|
|
|
|
struct audit_names preallocated_names[AUDIT_NAMES];
|
|
|
|
int name_count; /* total records in names_list */
|
|
|
|
struct list_head names_list; /* anchor for struct audit_names->list */
|
2006-06-15 00:45:21 +02:00
|
|
|
char * filterkey; /* key for rule that triggered record */
|
2008-02-15 04:38:33 +01:00
|
|
|
struct path pwd;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct audit_context *previous; /* For nested syscalls */
|
|
|
|
struct audit_aux_data *aux;
|
2007-03-30 00:01:04 +02:00
|
|
|
struct audit_aux_data *aux_pids;
|
2008-12-10 01:50:34 +01:00
|
|
|
struct sockaddr_storage *sockaddr;
|
|
|
|
size_t sockaddr_len;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Save things to print about task_struct */
|
2006-05-06 14:22:52 +02:00
|
|
|
pid_t pid, ppid;
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t uid, euid, suid, fsuid;
|
|
|
|
kgid_t gid, egid, sgid, fsgid;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long personality;
|
2005-04-29 17:08:28 +02:00
|
|
|
int arch;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-03-20 18:58:35 +01:00
|
|
|
pid_t target_pid;
|
2012-09-11 07:39:43 +02:00
|
|
|
kuid_t target_auid;
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t target_uid;
|
2008-01-08 16:06:53 +01:00
|
|
|
unsigned int target_sessionid;
|
2007-03-20 18:58:35 +01:00
|
|
|
u32 target_sid;
|
2008-01-07 19:40:17 +01:00
|
|
|
char target_comm[TASK_COMM_LEN];
|
2007-03-20 18:58:35 +01:00
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
struct audit_tree_refs *trees, *first_trees;
|
2009-06-24 06:02:38 +02:00
|
|
|
struct list_head killed_trees;
|
2009-08-07 22:54:29 +02:00
|
|
|
int tree_count;
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
|
2008-12-10 09:16:51 +01:00
|
|
|
int type;
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
int nargs;
|
|
|
|
long args[6];
|
|
|
|
} socketcall;
|
2008-12-10 09:40:06 +01:00
|
|
|
struct {
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t uid;
|
|
|
|
kgid_t gid;
|
2011-07-27 20:03:22 +02:00
|
|
|
umode_t mode;
|
2008-12-10 09:40:06 +01:00
|
|
|
u32 osid;
|
2008-12-10 09:47:15 +01:00
|
|
|
int has_perm;
|
|
|
|
uid_t perm_uid;
|
|
|
|
gid_t perm_gid;
|
2011-07-27 20:03:22 +02:00
|
|
|
umode_t perm_mode;
|
2008-12-10 09:47:15 +01:00
|
|
|
unsigned long qbytes;
|
2008-12-10 09:40:06 +01:00
|
|
|
} ipc;
|
2008-12-10 12:58:59 +01:00
|
|
|
struct {
|
|
|
|
mqd_t mqdes;
|
|
|
|
struct mq_attr mqstat;
|
|
|
|
} mq_getsetattr;
|
2008-12-10 13:16:12 +01:00
|
|
|
struct {
|
|
|
|
mqd_t mqdes;
|
|
|
|
int sigev_signo;
|
|
|
|
} mq_notify;
|
2008-12-14 09:46:48 +01:00
|
|
|
struct {
|
|
|
|
mqd_t mqdes;
|
|
|
|
size_t msg_len;
|
|
|
|
unsigned int msg_prio;
|
|
|
|
struct timespec abs_timeout;
|
|
|
|
} mq_sendrecv;
|
2008-12-14 10:02:26 +01:00
|
|
|
struct {
|
|
|
|
int oflag;
|
2011-07-26 11:26:10 +02:00
|
|
|
umode_t mode;
|
2008-12-14 10:02:26 +01:00
|
|
|
struct mq_attr attr;
|
|
|
|
} mq_open;
|
2009-01-04 20:52:57 +01:00
|
|
|
struct {
|
|
|
|
pid_t pid;
|
|
|
|
struct audit_cap_data cap;
|
|
|
|
} capset;
|
2010-10-30 08:54:44 +02:00
|
|
|
struct {
|
|
|
|
int fd;
|
|
|
|
int flags;
|
|
|
|
} mmap;
|
2008-12-10 09:16:51 +01:00
|
|
|
};
|
2008-12-14 10:57:47 +01:00
|
|
|
int fds[2];
|
2008-12-10 09:16:51 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#if AUDIT_DEBUG
|
|
|
|
int put_count;
|
|
|
|
int ino_count;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2006-09-01 01:26:40 +02:00
|
|
|
static inline int open_arg(int flags, int mask)
|
|
|
|
{
|
|
|
|
int n = ACC_MODE(flags);
|
|
|
|
if (flags & (O_TRUNC | O_CREAT))
|
|
|
|
n |= AUDIT_PERM_WRITE;
|
|
|
|
return n & mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int audit_match_perm(struct audit_context *ctx, int mask)
|
|
|
|
{
|
2008-08-18 18:45:51 +02:00
|
|
|
unsigned n;
|
2008-08-02 04:56:37 +02:00
|
|
|
if (unlikely(!ctx))
|
|
|
|
return 0;
|
2008-08-18 18:45:51 +02:00
|
|
|
n = ctx->major;
|
2008-10-13 11:40:53 +02:00
|
|
|
|
2006-09-01 01:26:40 +02:00
|
|
|
switch (audit_classify_syscall(ctx->arch, n)) {
|
|
|
|
case 0: /* native */
|
|
|
|
if ((mask & AUDIT_PERM_WRITE) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_WRITE, n))
|
|
|
|
return 1;
|
|
|
|
if ((mask & AUDIT_PERM_READ) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_READ, n))
|
|
|
|
return 1;
|
|
|
|
if ((mask & AUDIT_PERM_ATTR) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_CHATTR, n))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
case 1: /* 32bit on biarch */
|
|
|
|
if ((mask & AUDIT_PERM_WRITE) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_WRITE_32, n))
|
|
|
|
return 1;
|
|
|
|
if ((mask & AUDIT_PERM_READ) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_READ_32, n))
|
|
|
|
return 1;
|
|
|
|
if ((mask & AUDIT_PERM_ATTR) &&
|
|
|
|
audit_match_class(AUDIT_CLASS_CHATTR_32, n))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
case 2: /* open */
|
|
|
|
return mask & ACC_MODE(ctx->argv[1]);
|
|
|
|
case 3: /* openat */
|
|
|
|
return mask & ACC_MODE(ctx->argv[2]);
|
|
|
|
case 4: /* socketcall */
|
|
|
|
return ((mask & AUDIT_PERM_WRITE) && ctx->argv[0] == SYS_BIND);
|
|
|
|
case 5: /* execve */
|
|
|
|
return mask & AUDIT_PERM_EXEC;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
static int audit_match_filetype(struct audit_context *ctx, int val)
|
2008-04-28 10:15:49 +02:00
|
|
|
{
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2012-01-03 20:23:05 +01:00
|
|
|
umode_t mode = (umode_t)val;
|
2008-08-02 04:56:37 +02:00
|
|
|
|
|
|
|
if (unlikely(!ctx))
|
|
|
|
return 0;
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
|
|
|
if ((n->ino != -1) &&
|
|
|
|
((n->mode & S_IFMT) == mode))
|
2012-01-03 20:23:05 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2012-01-03 20:23:05 +01:00
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
return 0;
|
2008-04-28 10:15:49 +02:00
|
|
|
}
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
/*
|
|
|
|
* We keep a linked list of fixed-sized (31 pointer) arrays of audit_chunk *;
|
|
|
|
* ->first_trees points to its beginning, ->trees - to the current end of data.
|
|
|
|
* ->tree_count is the number of free entries in array pointed to by ->trees.
|
|
|
|
* Original condition is (NULL, NULL, 0); as soon as it grows we never revert to NULL,
|
|
|
|
* "empty" becomes (p, p, 31) afterwards. We don't shrink the list (and seriously,
|
|
|
|
* it's going to remain 1-element for almost any setup) until we free context itself.
|
|
|
|
* References in it _are_ dropped - at the same time we free/drop aux stuff.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_AUDIT_TREE
|
2009-01-27 00:09:45 +01:00
|
|
|
static void audit_set_auditable(struct audit_context *ctx)
|
|
|
|
{
|
|
|
|
if (!ctx->prio) {
|
|
|
|
ctx->prio = 1;
|
|
|
|
ctx->current_state = AUDIT_RECORD_CONTEXT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
static int put_tree_ref(struct audit_context *ctx, struct audit_chunk *chunk)
|
|
|
|
{
|
|
|
|
struct audit_tree_refs *p = ctx->trees;
|
|
|
|
int left = ctx->tree_count;
|
|
|
|
if (likely(left)) {
|
|
|
|
p->c[--left] = chunk;
|
|
|
|
ctx->tree_count = left;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
p = p->next;
|
|
|
|
if (p) {
|
|
|
|
p->c[30] = chunk;
|
|
|
|
ctx->trees = p;
|
|
|
|
ctx->tree_count = 30;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int grow_tree_refs(struct audit_context *ctx)
|
|
|
|
{
|
|
|
|
struct audit_tree_refs *p = ctx->trees;
|
|
|
|
ctx->trees = kzalloc(sizeof(struct audit_tree_refs), GFP_KERNEL);
|
|
|
|
if (!ctx->trees) {
|
|
|
|
ctx->trees = p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (p)
|
|
|
|
p->next = ctx->trees;
|
|
|
|
else
|
|
|
|
ctx->first_trees = ctx->trees;
|
|
|
|
ctx->tree_count = 31;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void unroll_tree_refs(struct audit_context *ctx,
|
|
|
|
struct audit_tree_refs *p, int count)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_AUDIT_TREE
|
|
|
|
struct audit_tree_refs *q;
|
|
|
|
int n;
|
|
|
|
if (!p) {
|
|
|
|
/* we started with empty chain */
|
|
|
|
p = ctx->first_trees;
|
|
|
|
count = 31;
|
|
|
|
/* if the very first allocation has failed, nothing to do */
|
|
|
|
if (!p)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
n = count;
|
|
|
|
for (q = p; q != ctx->trees; q = q->next, n = 31) {
|
|
|
|
while (n--) {
|
|
|
|
audit_put_chunk(q->c[n]);
|
|
|
|
q->c[n] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (n-- > ctx->tree_count) {
|
|
|
|
audit_put_chunk(q->c[n]);
|
|
|
|
q->c[n] = NULL;
|
|
|
|
}
|
|
|
|
ctx->trees = p;
|
|
|
|
ctx->tree_count = count;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_tree_refs(struct audit_context *ctx)
|
|
|
|
{
|
|
|
|
struct audit_tree_refs *p, *q;
|
|
|
|
for (p = ctx->first_trees; p; p = q) {
|
|
|
|
q = p->next;
|
|
|
|
kfree(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int match_tree_refs(struct audit_context *ctx, struct audit_tree *tree)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_AUDIT_TREE
|
|
|
|
struct audit_tree_refs *p;
|
|
|
|
int n;
|
|
|
|
if (!tree)
|
|
|
|
return 0;
|
|
|
|
/* full ones */
|
|
|
|
for (p = ctx->first_trees; p != ctx->trees; p = p->next) {
|
|
|
|
for (n = 0; n < 31; n++)
|
|
|
|
if (audit_tree_match(p->c[n], tree))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* partial */
|
|
|
|
if (p) {
|
|
|
|
for (n = ctx->tree_count; n < 31; n++)
|
|
|
|
if (audit_tree_match(p->c[n], tree))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-11 11:18:08 +02:00
|
|
|
static int audit_compare_uid(kuid_t uid,
|
|
|
|
struct audit_names *name,
|
|
|
|
struct audit_field *f,
|
|
|
|
struct audit_context *ctx)
|
2012-01-03 20:23:08 +01:00
|
|
|
{
|
|
|
|
struct audit_names *n;
|
|
|
|
int rc;
|
2012-09-11 11:18:08 +02:00
|
|
|
|
2012-01-03 20:23:08 +01:00
|
|
|
if (name) {
|
2012-09-11 11:18:08 +02:00
|
|
|
rc = audit_uid_comparator(uid, f->op, name->uid);
|
2012-01-03 20:23:08 +01:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
2012-09-11 11:18:08 +02:00
|
|
|
|
2012-01-03 20:23:08 +01:00
|
|
|
if (ctx) {
|
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
2012-09-11 11:18:08 +02:00
|
|
|
rc = audit_uid_comparator(uid, f->op, n->uid);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-01-03 20:23:08 +01:00
|
|
|
|
2012-09-11 11:18:08 +02:00
|
|
|
static int audit_compare_gid(kgid_t gid,
|
|
|
|
struct audit_names *name,
|
|
|
|
struct audit_field *f,
|
|
|
|
struct audit_context *ctx)
|
|
|
|
{
|
|
|
|
struct audit_names *n;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (name) {
|
|
|
|
rc = audit_gid_comparator(gid, f->op, name->gid);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ctx) {
|
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
|
|
|
rc = audit_gid_comparator(gid, f->op, n->gid);
|
2012-01-03 20:23:08 +01:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:08 +01:00
|
|
|
static int audit_field_compare(struct task_struct *tsk,
|
|
|
|
const struct cred *cred,
|
|
|
|
struct audit_field *f,
|
|
|
|
struct audit_context *ctx,
|
|
|
|
struct audit_names *name)
|
|
|
|
{
|
|
|
|
switch (f->val) {
|
2011-12-14 01:17:51 +01:00
|
|
|
/* process to file object comparisons */
|
2012-01-03 20:23:08 +01:00
|
|
|
case AUDIT_COMPARE_UID_TO_OBJ_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_uid(cred->uid, name, f, ctx);
|
2012-01-03 20:23:08 +01:00
|
|
|
case AUDIT_COMPARE_GID_TO_OBJ_GID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_gid(cred->gid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_EUID_TO_OBJ_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_uid(cred->euid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_EGID_TO_OBJ_GID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_gid(cred->egid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_AUID_TO_OBJ_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_uid(tsk->loginuid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_SUID_TO_OBJ_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_uid(cred->suid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_SGID_TO_OBJ_GID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_gid(cred->sgid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_FSUID_TO_OBJ_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_uid(cred->fsuid, name, f, ctx);
|
2011-12-14 01:17:51 +01:00
|
|
|
case AUDIT_COMPARE_FSGID_TO_OBJ_GID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_compare_gid(cred->fsgid, name, f, ctx);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* uid comparisons */
|
|
|
|
case AUDIT_COMPARE_UID_TO_AUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->uid, f->op, tsk->loginuid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_UID_TO_EUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->uid, f->op, cred->euid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_UID_TO_SUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->uid, f->op, cred->suid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_UID_TO_FSUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->uid, f->op, cred->fsuid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* auid comparisons */
|
|
|
|
case AUDIT_COMPARE_AUID_TO_EUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(tsk->loginuid, f->op, cred->euid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_AUID_TO_SUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(tsk->loginuid, f->op, cred->suid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_AUID_TO_FSUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(tsk->loginuid, f->op, cred->fsuid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* euid comparisons */
|
|
|
|
case AUDIT_COMPARE_EUID_TO_SUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->euid, f->op, cred->suid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_EUID_TO_FSUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->euid, f->op, cred->fsuid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* suid comparisons */
|
|
|
|
case AUDIT_COMPARE_SUID_TO_FSUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_uid_comparator(cred->suid, f->op, cred->fsuid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* gid comparisons */
|
|
|
|
case AUDIT_COMPARE_GID_TO_EGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->gid, f->op, cred->egid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_GID_TO_SGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->gid, f->op, cred->sgid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_GID_TO_FSGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->gid, f->op, cred->fsgid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* egid comparisons */
|
|
|
|
case AUDIT_COMPARE_EGID_TO_SGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->egid, f->op, cred->sgid);
|
2012-01-04 21:24:31 +01:00
|
|
|
case AUDIT_COMPARE_EGID_TO_FSGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->egid, f->op, cred->fsgid);
|
2012-01-04 21:24:31 +01:00
|
|
|
/* sgid comparison */
|
|
|
|
case AUDIT_COMPARE_SGID_TO_FSGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
return audit_gid_comparator(cred->sgid, f->op, cred->fsgid);
|
2012-01-03 20:23:08 +01:00
|
|
|
default:
|
|
|
|
WARN(1, "Missing AUDIT_COMPARE define. Report as a bug\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
/* Determine if any context name data matches a rule's watch data */
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Compare a task_struct with an audit_rule. Return 1 on match, 0
|
2011-04-27 15:10:49 +02:00
|
|
|
* otherwise.
|
|
|
|
*
|
|
|
|
* If task_creation is true, this is an explicit indication that we are
|
|
|
|
* filtering a task rule at task creation time. This and tsk == current are
|
|
|
|
* the only situations where tsk->cred may be accessed without an rcu read lock.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static int audit_filter_rules(struct task_struct *tsk,
|
2006-02-07 18:05:27 +01:00
|
|
|
struct audit_krule *rule,
|
2005-04-17 00:20:36 +02:00
|
|
|
struct audit_context *ctx,
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
struct audit_names *name,
|
2011-04-27 15:10:49 +02:00
|
|
|
enum audit_state *state,
|
|
|
|
bool task_creation)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-04-27 15:10:49 +02:00
|
|
|
const struct cred *cred;
|
2012-01-03 20:23:05 +01:00
|
|
|
int i, need_sid = 1;
|
2006-03-11 01:14:06 +01:00
|
|
|
u32 sid;
|
|
|
|
|
2011-04-27 15:10:49 +02:00
|
|
|
cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 0; i < rule->field_count; i++) {
|
2006-02-07 18:05:27 +01:00
|
|
|
struct audit_field *f = &rule->fields[i];
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2005-04-17 00:20:36 +02:00
|
|
|
int result = 0;
|
|
|
|
|
2006-02-07 18:05:27 +01:00
|
|
|
switch (f->type) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case AUDIT_PID:
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(tsk->pid, f->op, f->val);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2006-05-06 14:26:27 +02:00
|
|
|
case AUDIT_PPID:
|
2006-09-29 06:08:50 +02:00
|
|
|
if (ctx) {
|
|
|
|
if (!ctx->ppid)
|
|
|
|
ctx->ppid = sys_getppid();
|
2006-05-06 14:26:27 +02:00
|
|
|
result = audit_comparator(ctx->ppid, f->op, f->val);
|
2006-09-29 06:08:50 +02:00
|
|
|
}
|
2006-05-06 14:26:27 +02:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case AUDIT_UID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(cred->uid, f->op, f->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_EUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(cred->euid, f->op, f->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_SUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(cred->suid, f->op, f->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_FSUID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(cred->fsuid, f->op, f->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_GID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_gid_comparator(cred->gid, f->op, f->gid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_EGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_gid_comparator(cred->egid, f->op, f->gid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_SGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_gid_comparator(cred->sgid, f->op, f->gid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_FSGID:
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_gid_comparator(cred->fsgid, f->op, f->gid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_PERS:
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(tsk->personality, f->op, f->val);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2005-04-29 17:08:28 +02:00
|
|
|
case AUDIT_ARCH:
|
2007-10-18 12:06:09 +02:00
|
|
|
if (ctx)
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(ctx->arch, f->op, f->val);
|
2005-04-29 17:08:28 +02:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
case AUDIT_EXIT:
|
|
|
|
if (ctx && ctx->return_valid)
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(ctx->return_code, f->op, f->val);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_SUCCESS:
|
2005-08-27 11:25:43 +02:00
|
|
|
if (ctx && ctx->return_valid) {
|
2006-02-07 18:05:27 +01:00
|
|
|
if (f->val)
|
|
|
|
result = audit_comparator(ctx->return_valid, f->op, AUDITSC_SUCCESS);
|
2005-08-27 11:25:43 +02:00
|
|
|
else
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(ctx->return_valid, f->op, AUDITSC_FAILURE);
|
2005-08-27 11:25:43 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case AUDIT_DEVMAJOR:
|
2012-01-03 20:23:05 +01:00
|
|
|
if (name) {
|
|
|
|
if (audit_comparator(MAJOR(name->dev), f->op, f->val) ||
|
|
|
|
audit_comparator(MAJOR(name->rdev), f->op, f->val))
|
|
|
|
++result;
|
|
|
|
} else if (ctx) {
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
2012-01-03 20:23:05 +01:00
|
|
|
if (audit_comparator(MAJOR(n->dev), f->op, f->val) ||
|
|
|
|
audit_comparator(MAJOR(n->rdev), f->op, f->val)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AUDIT_DEVMINOR:
|
2012-01-03 20:23:05 +01:00
|
|
|
if (name) {
|
|
|
|
if (audit_comparator(MINOR(name->dev), f->op, f->val) ||
|
|
|
|
audit_comparator(MINOR(name->rdev), f->op, f->val))
|
|
|
|
++result;
|
|
|
|
} else if (ctx) {
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
2012-01-03 20:23:05 +01:00
|
|
|
if (audit_comparator(MINOR(n->dev), f->op, f->val) ||
|
|
|
|
audit_comparator(MINOR(n->rdev), f->op, f->val)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AUDIT_INODE:
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
if (name)
|
2006-06-09 05:19:31 +02:00
|
|
|
result = (name->ino == f->val);
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
else if (ctx) {
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
|
|
|
if (audit_comparator(n->ino, f->op, f->val)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2012-01-03 20:23:07 +01:00
|
|
|
case AUDIT_OBJ_UID:
|
|
|
|
if (name) {
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(name->uid, f->op, f->uid);
|
2012-01-03 20:23:07 +01:00
|
|
|
} else if (ctx) {
|
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
2012-09-11 11:18:08 +02:00
|
|
|
if (audit_uid_comparator(n->uid, f->op, f->uid)) {
|
2012-01-03 20:23:07 +01:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2012-01-03 20:23:07 +01:00
|
|
|
case AUDIT_OBJ_GID:
|
|
|
|
if (name) {
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_gid_comparator(name->gid, f->op, f->gid);
|
2012-01-03 20:23:07 +01:00
|
|
|
} else if (ctx) {
|
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
2012-09-11 11:18:08 +02:00
|
|
|
if (audit_gid_comparator(n->gid, f->op, f->gid)) {
|
2012-01-03 20:23:07 +01:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
case AUDIT_WATCH:
|
2009-12-18 02:12:04 +01:00
|
|
|
if (name)
|
|
|
|
result = audit_watch_compare(rule->watch, name->ino, name->dev);
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
break;
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
case AUDIT_DIR:
|
|
|
|
if (ctx)
|
|
|
|
result = match_tree_refs(ctx, rule->tree);
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case AUDIT_LOGINUID:
|
|
|
|
result = 0;
|
|
|
|
if (ctx)
|
2012-09-11 11:18:08 +02:00
|
|
|
result = audit_uid_comparator(tsk->loginuid, f->op, f->uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2006-06-29 23:56:39 +02:00
|
|
|
case AUDIT_SUBJ_USER:
|
|
|
|
case AUDIT_SUBJ_ROLE:
|
|
|
|
case AUDIT_SUBJ_TYPE:
|
|
|
|
case AUDIT_SUBJ_SEN:
|
|
|
|
case AUDIT_SUBJ_CLR:
|
2006-03-11 01:14:06 +01:00
|
|
|
/* NOTE: this may return negative values indicating
|
|
|
|
a temporary error. We simply treat this as a
|
|
|
|
match for now to avoid losing information that
|
|
|
|
may be wanted. An error message will also be
|
|
|
|
logged upon error */
|
2008-04-19 01:59:43 +02:00
|
|
|
if (f->lsm_rule) {
|
2006-04-11 14:50:56 +02:00
|
|
|
if (need_sid) {
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(tsk, &sid);
|
2006-04-11 14:50:56 +02:00
|
|
|
need_sid = 0;
|
|
|
|
}
|
2008-03-01 21:01:11 +01:00
|
|
|
result = security_audit_rule_match(sid, f->type,
|
2006-03-11 01:14:06 +01:00
|
|
|
f->op,
|
2008-04-19 01:59:43 +02:00
|
|
|
f->lsm_rule,
|
2006-03-11 01:14:06 +01:00
|
|
|
ctx);
|
2006-04-11 14:50:56 +02:00
|
|
|
}
|
2006-03-11 01:14:06 +01:00
|
|
|
break;
|
2006-06-29 23:57:08 +02:00
|
|
|
case AUDIT_OBJ_USER:
|
|
|
|
case AUDIT_OBJ_ROLE:
|
|
|
|
case AUDIT_OBJ_TYPE:
|
|
|
|
case AUDIT_OBJ_LEV_LOW:
|
|
|
|
case AUDIT_OBJ_LEV_HIGH:
|
|
|
|
/* The above note for AUDIT_SUBJ_USER...AUDIT_SUBJ_CLR
|
|
|
|
also applies here */
|
2008-04-19 01:59:43 +02:00
|
|
|
if (f->lsm_rule) {
|
2006-06-29 23:57:08 +02:00
|
|
|
/* Find files that match */
|
|
|
|
if (name) {
|
2008-03-01 21:01:11 +01:00
|
|
|
result = security_audit_rule_match(
|
2006-06-29 23:57:08 +02:00
|
|
|
name->osid, f->type, f->op,
|
2008-04-19 01:59:43 +02:00
|
|
|
f->lsm_rule, ctx);
|
2006-06-29 23:57:08 +02:00
|
|
|
} else if (ctx) {
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
|
|
|
if (security_audit_rule_match(n->osid, f->type,
|
|
|
|
f->op, f->lsm_rule,
|
|
|
|
ctx)) {
|
2006-06-29 23:57:08 +02:00
|
|
|
++result;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Find ipc objects that match */
|
2008-12-10 09:40:06 +01:00
|
|
|
if (!ctx || ctx->type != AUDIT_IPC)
|
|
|
|
break;
|
|
|
|
if (security_audit_rule_match(ctx->ipc.osid,
|
|
|
|
f->type, f->op,
|
|
|
|
f->lsm_rule, ctx))
|
|
|
|
++result;
|
2006-06-29 23:57:08 +02:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case AUDIT_ARG0:
|
|
|
|
case AUDIT_ARG1:
|
|
|
|
case AUDIT_ARG2:
|
|
|
|
case AUDIT_ARG3:
|
|
|
|
if (ctx)
|
2006-02-07 18:05:27 +01:00
|
|
|
result = audit_comparator(ctx->argv[f->type-AUDIT_ARG0], f->op, f->val);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2006-06-15 00:45:21 +02:00
|
|
|
case AUDIT_FILTERKEY:
|
|
|
|
/* ignore this field for filtering */
|
|
|
|
result = 1;
|
|
|
|
break;
|
2006-09-01 01:26:40 +02:00
|
|
|
case AUDIT_PERM:
|
|
|
|
result = audit_match_perm(ctx, f->val);
|
|
|
|
break;
|
2008-04-28 10:15:49 +02:00
|
|
|
case AUDIT_FILETYPE:
|
|
|
|
result = audit_match_filetype(ctx, f->val);
|
|
|
|
break;
|
2012-01-03 20:23:08 +01:00
|
|
|
case AUDIT_FIELD_COMPARE:
|
|
|
|
result = audit_field_compare(tsk, cred, f, ctx, name);
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2011-04-27 15:10:49 +02:00
|
|
|
if (!result)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-15 05:45:27 +01:00
|
|
|
|
|
|
|
if (ctx) {
|
|
|
|
if (rule->prio <= ctx->prio)
|
|
|
|
return 0;
|
|
|
|
if (rule->filterkey) {
|
|
|
|
kfree(ctx->filterkey);
|
|
|
|
ctx->filterkey = kstrdup(rule->filterkey, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
ctx->prio = rule->prio;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (rule->action) {
|
|
|
|
case AUDIT_NEVER: *state = AUDIT_DISABLED; break;
|
|
|
|
case AUDIT_ALWAYS: *state = AUDIT_RECORD_CONTEXT; break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* At process creation time, we can determine if system-call auditing is
|
|
|
|
* completely disabled for this task. Since we only have the task
|
|
|
|
* structure at this point, we can only check uid and gid.
|
|
|
|
*/
|
2008-12-16 09:51:22 +01:00
|
|
|
static enum audit_state audit_filter_task(struct task_struct *tsk, char **key)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_entry *e;
|
|
|
|
enum audit_state state;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2005-06-19 20:35:50 +02:00
|
|
|
list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
|
2011-04-27 15:10:49 +02:00
|
|
|
if (audit_filter_rules(tsk, &e->rule, NULL, NULL,
|
|
|
|
&state, true)) {
|
2008-12-16 09:51:22 +01:00
|
|
|
if (state == AUDIT_RECORD_CONTEXT)
|
|
|
|
*key = kstrdup(e->rule.filterkey, GFP_ATOMIC);
|
2005-04-17 00:20:36 +02:00
|
|
|
rcu_read_unlock();
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
return AUDIT_BUILD_CONTEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* At syscall entry and exit time, this filter is called if the
|
|
|
|
* audit_state is not low enough that auditing cannot take place, but is
|
2005-05-13 19:35:15 +02:00
|
|
|
* also not high enough that we already know we have to write an audit
|
2005-09-13 21:47:11 +02:00
|
|
|
* record (i.e., the state is AUDIT_SETUP_CONTEXT or AUDIT_BUILD_CONTEXT).
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
static enum audit_state audit_filter_syscall(struct task_struct *tsk,
|
|
|
|
struct audit_context *ctx,
|
|
|
|
struct list_head *list)
|
|
|
|
{
|
|
|
|
struct audit_entry *e;
|
2005-08-17 15:49:57 +02:00
|
|
|
enum audit_state state;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-14 15:40:06 +02:00
|
|
|
if (audit_pid && tsk->tgid == audit_pid)
|
2005-06-20 17:07:33 +02:00
|
|
|
return AUDIT_DISABLED;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
rcu_read_lock();
|
2005-08-17 15:49:57 +02:00
|
|
|
if (!list_empty(list)) {
|
[PATCH] Filter rule comparators
Currently, audit only supports the "=" and "!=" operators in the -F
filter rules.
This patch reworks the support for "=" and "!=", and adds support
for ">", ">=", "<", and "<=".
This turned out to be a pretty clean, and simply process. I ended up
using the high order bits of the "field", as suggested by Steve and Amy.
This allowed for no changes whatsoever to the netlink communications.
See the documentation within the patch in the include/linux/audit.h
area, where there is a table that explains the reasoning of the bitmask
assignments clearly.
The patch adds a new function, audit_comparator(left, op, right).
This function will perform the specified comparison (op, which defaults
to "==" for backward compatibility) between two values (left and right).
If the negate bit is on, it will negate whatever that result was. This
value is returned.
Signed-off-by: Dustin Kirkland <dustin.kirkland@us.ibm.com>
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
2005-11-03 16:41:46 +01:00
|
|
|
int word = AUDIT_WORD(ctx->major);
|
|
|
|
int bit = AUDIT_BIT(ctx->major);
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(e, list, list) {
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
if ((e->rule.mask[word] & bit) == bit &&
|
|
|
|
audit_filter_rules(tsk, &e->rule, ctx, NULL,
|
2011-04-27 15:10:49 +02:00
|
|
|
&state, false)) {
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
rcu_read_unlock();
|
2008-12-15 05:45:27 +01:00
|
|
|
ctx->current_state = state;
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
return state;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
return AUDIT_BUILD_CONTEXT;
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
/*
|
|
|
|
* Given an audit_name check the inode hash table to see if they match.
|
|
|
|
* Called holding the rcu read lock to protect the use of audit_inode_hash
|
|
|
|
*/
|
|
|
|
static int audit_filter_inode_name(struct task_struct *tsk,
|
|
|
|
struct audit_names *n,
|
|
|
|
struct audit_context *ctx) {
|
|
|
|
int word, bit;
|
|
|
|
int h = audit_hash_ino((u32)n->ino);
|
|
|
|
struct list_head *list = &audit_inode_hash[h];
|
|
|
|
struct audit_entry *e;
|
|
|
|
enum audit_state state;
|
|
|
|
|
|
|
|
word = AUDIT_WORD(ctx->major);
|
|
|
|
bit = AUDIT_BIT(ctx->major);
|
|
|
|
|
|
|
|
if (list_empty(list))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(e, list, list) {
|
|
|
|
if ((e->rule.mask[word] & bit) == bit &&
|
|
|
|
audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) {
|
|
|
|
ctx->current_state = state;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* At syscall exit time, this filter is called if any audit_names have been
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
* collected during syscall processing. We only check rules in sublists at hash
|
2012-01-03 20:23:05 +01:00
|
|
|
* buckets applicable to the inode numbers in audit_names.
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
* Regarding audit_state, same rules apply as for audit_filter_syscall().
|
|
|
|
*/
|
2008-12-15 05:45:27 +01:00
|
|
|
void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx)
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
{
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
|
|
|
|
if (audit_pid && tsk->tgid == audit_pid)
|
2008-12-15 05:45:27 +01:00
|
|
|
return;
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &ctx->names_list, list) {
|
|
|
|
if (audit_filter_inode_name(tsk, n, ctx))
|
|
|
|
break;
|
2005-06-19 20:35:50 +02:00
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline struct audit_context *audit_get_context(struct task_struct *tsk,
|
|
|
|
int return_valid,
|
2009-04-01 21:47:27 +02:00
|
|
|
long return_code)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = tsk->audit_context;
|
|
|
|
|
2012-01-03 20:23:06 +01:00
|
|
|
if (!context)
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
context->return_valid = return_valid;
|
2008-01-07 19:34:51 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we need to fix up the return code in the audit logs if the actual
|
|
|
|
* return codes are later going to be fixed up by the arch specific
|
|
|
|
* signal handlers
|
|
|
|
*
|
|
|
|
* This is actually a test for:
|
|
|
|
* (rc == ERESTARTSYS ) || (rc == ERESTARTNOINTR) ||
|
|
|
|
* (rc == ERESTARTNOHAND) || (rc == ERESTART_RESTARTBLOCK)
|
|
|
|
*
|
|
|
|
* but is faster than a bunch of ||
|
|
|
|
*/
|
|
|
|
if (unlikely(return_code <= -ERESTARTSYS) &&
|
|
|
|
(return_code >= -ERESTART_RESTARTBLOCK) &&
|
|
|
|
(return_code != -ENOIOCTLCMD))
|
|
|
|
context->return_code = -EINTR;
|
|
|
|
else
|
|
|
|
context->return_code = return_code;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-15 05:45:27 +01:00
|
|
|
if (context->in_syscall && !context->dummy) {
|
|
|
|
audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
|
|
|
|
audit_filter_inodes(tsk, context);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
tsk->audit_context = NULL;
|
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void audit_free_names(struct audit_context *context)
|
|
|
|
{
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n, *next;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#if AUDIT_DEBUG == 2
|
2008-12-15 05:45:27 +01:00
|
|
|
if (context->put_count + context->ino_count != context->name_count) {
|
2005-11-03 17:00:25 +01:00
|
|
|
printk(KERN_ERR "%s:%d(:%d): major=%d in_syscall=%d"
|
2005-04-17 00:20:36 +02:00
|
|
|
" name_count=%d put_count=%d"
|
|
|
|
" ino_count=%d [NOT freeing]\n",
|
2005-11-03 17:00:25 +01:00
|
|
|
__FILE__, __LINE__,
|
2005-04-17 00:20:36 +02:00
|
|
|
context->serial, context->major, context->in_syscall,
|
|
|
|
context->name_count, context->put_count,
|
|
|
|
context->ino_count);
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &context->names_list, list) {
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_ERR "names[%d] = %p = %s\n", i,
|
2012-01-03 20:23:05 +01:00
|
|
|
n->name, n->name ?: "(null)");
|
2005-11-03 18:15:16 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
dump_stack();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#if AUDIT_DEBUG
|
|
|
|
context->put_count = 0;
|
|
|
|
context->ino_count = 0;
|
|
|
|
#endif
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry_safe(n, next, &context->names_list, list) {
|
|
|
|
list_del(&n->list);
|
|
|
|
if (n->name && n->name_put)
|
|
|
|
__putname(n->name);
|
|
|
|
if (n->should_free)
|
|
|
|
kfree(n);
|
2005-11-03 18:15:16 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
context->name_count = 0;
|
2008-02-15 04:38:33 +01:00
|
|
|
path_put(&context->pwd);
|
|
|
|
context->pwd.dentry = NULL;
|
|
|
|
context->pwd.mnt = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void audit_free_aux(struct audit_context *context)
|
|
|
|
{
|
|
|
|
struct audit_aux_data *aux;
|
|
|
|
|
|
|
|
while ((aux = context->aux)) {
|
|
|
|
context->aux = aux->next;
|
|
|
|
kfree(aux);
|
|
|
|
}
|
2007-03-30 00:01:04 +02:00
|
|
|
while ((aux = context->aux_pids)) {
|
|
|
|
context->aux_pids = aux->next;
|
|
|
|
kfree(aux);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void audit_zero_context(struct audit_context *context,
|
|
|
|
enum audit_state state)
|
|
|
|
{
|
|
|
|
memset(context, 0, sizeof(*context));
|
|
|
|
context->state = state;
|
2008-12-15 05:45:27 +01:00
|
|
|
context->prio = state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct audit_context *audit_alloc_context(enum audit_state state)
|
|
|
|
{
|
|
|
|
struct audit_context *context;
|
|
|
|
|
|
|
|
if (!(context = kmalloc(sizeof(*context), GFP_KERNEL)))
|
|
|
|
return NULL;
|
|
|
|
audit_zero_context(context, state);
|
2009-06-24 06:02:38 +02:00
|
|
|
INIT_LIST_HEAD(&context->killed_trees);
|
2012-01-03 20:23:05 +01:00
|
|
|
INIT_LIST_HEAD(&context->names_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
return context;
|
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_alloc - allocate an audit context block for a task
|
|
|
|
* @tsk: task
|
|
|
|
*
|
|
|
|
* Filter on the task information and allocate a per-task audit context
|
2005-04-17 00:20:36 +02:00
|
|
|
* if necessary. Doing so turns on system call auditing for the
|
|
|
|
* specified task. This is called from copy_process, so no lock is
|
2005-09-13 21:47:11 +02:00
|
|
|
* needed.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
int audit_alloc(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
struct audit_context *context;
|
|
|
|
enum audit_state state;
|
2008-12-16 09:51:22 +01:00
|
|
|
char *key = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-08 23:38:31 +01:00
|
|
|
if (likely(!audit_ever_enabled))
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0; /* Return if not auditing. */
|
|
|
|
|
2008-12-16 09:51:22 +01:00
|
|
|
state = audit_filter_task(tsk, &key);
|
2012-01-03 20:23:06 +01:00
|
|
|
if (state == AUDIT_DISABLED)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!(context = audit_alloc_context(state))) {
|
2008-12-16 09:51:22 +01:00
|
|
|
kfree(key);
|
2005-04-17 00:20:36 +02:00
|
|
|
audit_log_lost("out of memory in audit_alloc");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-12-16 09:51:22 +01:00
|
|
|
context->filterkey = key;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
tsk->audit_context = context;
|
|
|
|
set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void audit_free_context(struct audit_context *context)
|
|
|
|
{
|
|
|
|
struct audit_context *previous;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
previous = context->previous;
|
|
|
|
if (previous || (count && count < 10)) {
|
|
|
|
++count;
|
|
|
|
printk(KERN_ERR "audit(:%d): major=%d name_count=%d:"
|
|
|
|
" freeing multiple contexts (%d)\n",
|
|
|
|
context->serial, context->major,
|
|
|
|
context->name_count, count);
|
|
|
|
}
|
|
|
|
audit_free_names(context);
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
unroll_tree_refs(context, NULL, 0);
|
|
|
|
free_tree_refs(context);
|
2005-04-17 00:20:36 +02:00
|
|
|
audit_free_aux(context);
|
2006-06-15 00:45:21 +02:00
|
|
|
kfree(context->filterkey);
|
2008-12-10 01:50:34 +01:00
|
|
|
kfree(context->sockaddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(context);
|
|
|
|
context = previous;
|
|
|
|
} while (context);
|
|
|
|
if (count >= 10)
|
|
|
|
printk(KERN_ERR "audit: freed %d contexts\n", count);
|
|
|
|
}
|
|
|
|
|
2006-11-27 20:11:54 +01:00
|
|
|
void audit_log_task_context(struct audit_buffer *ab)
|
2005-11-03 18:15:16 +01:00
|
|
|
{
|
|
|
|
char *ctx = NULL;
|
2007-03-12 17:17:42 +01:00
|
|
|
unsigned len;
|
|
|
|
int error;
|
|
|
|
u32 sid;
|
|
|
|
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(current, &sid);
|
2007-03-12 17:17:42 +01:00
|
|
|
if (!sid)
|
|
|
|
return;
|
2005-11-03 18:15:16 +01:00
|
|
|
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
error = security_secid_to_secctx(sid, &ctx, &len);
|
2007-03-12 17:17:42 +01:00
|
|
|
if (error) {
|
|
|
|
if (error != -EINVAL)
|
2005-11-03 18:15:16 +01:00
|
|
|
goto error_path;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
audit_log_format(ab, " subj=%s", ctx);
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_release_secctx(ctx, len);
|
2005-11-16 16:53:13 +01:00
|
|
|
return;
|
2005-11-03 18:15:16 +01:00
|
|
|
|
|
|
|
error_path:
|
2005-11-16 16:53:13 +01:00
|
|
|
audit_panic("error in audit_log_task_context");
|
2005-11-03 18:15:16 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-11-27 20:11:54 +01:00
|
|
|
EXPORT_SYMBOL(audit_log_task_context);
|
|
|
|
|
2012-06-14 19:04:35 +02:00
|
|
|
void audit_log_task_info(struct audit_buffer *ab, struct task_struct *tsk)
|
2005-04-18 19:47:35 +02:00
|
|
|
{
|
2012-06-14 19:04:35 +02:00
|
|
|
const struct cred *cred;
|
2006-03-30 03:02:55 +02:00
|
|
|
char name[sizeof(tsk->comm)];
|
|
|
|
struct mm_struct *mm = tsk->mm;
|
2012-06-14 19:04:35 +02:00
|
|
|
char *tty;
|
|
|
|
|
|
|
|
if (!ab)
|
|
|
|
return;
|
2005-04-18 19:47:35 +02:00
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
/* tsk == current */
|
2012-06-14 19:04:35 +02:00
|
|
|
cred = current_cred();
|
|
|
|
|
|
|
|
spin_lock_irq(&tsk->sighand->siglock);
|
|
|
|
if (tsk->signal && tsk->signal->tty && tsk->signal->tty->name)
|
|
|
|
tty = tsk->signal->tty->name;
|
|
|
|
else
|
|
|
|
tty = "(none)";
|
|
|
|
spin_unlock_irq(&tsk->sighand->siglock);
|
|
|
|
|
|
|
|
|
|
|
|
audit_log_format(ab,
|
|
|
|
" ppid=%ld pid=%d auid=%u uid=%u gid=%u"
|
|
|
|
" euid=%u suid=%u fsuid=%u"
|
|
|
|
" egid=%u sgid=%u fsgid=%u ses=%u tty=%s",
|
|
|
|
sys_getppid(),
|
|
|
|
tsk->pid,
|
2012-10-03 06:38:48 +02:00
|
|
|
from_kuid(&init_user_ns, tsk->loginuid),
|
|
|
|
from_kuid(&init_user_ns, cred->uid),
|
|
|
|
from_kgid(&init_user_ns, cred->gid),
|
|
|
|
from_kuid(&init_user_ns, cred->euid),
|
|
|
|
from_kuid(&init_user_ns, cred->suid),
|
|
|
|
from_kuid(&init_user_ns, cred->fsuid),
|
|
|
|
from_kgid(&init_user_ns, cred->egid),
|
|
|
|
from_kgid(&init_user_ns, cred->sgid),
|
|
|
|
from_kgid(&init_user_ns, cred->fsgid),
|
2012-06-14 19:04:35 +02:00
|
|
|
tsk->sessionid, tty);
|
2006-03-30 03:17:10 +02:00
|
|
|
|
2006-03-30 03:02:55 +02:00
|
|
|
get_task_comm(name, tsk);
|
2005-05-23 22:57:41 +02:00
|
|
|
audit_log_format(ab, " comm=");
|
|
|
|
audit_log_untrustedstring(ab, name);
|
2005-04-18 19:47:35 +02:00
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
if (mm) {
|
|
|
|
down_read(&mm->mmap_sem);
|
2012-10-09 01:28:51 +02:00
|
|
|
if (mm->exe_file)
|
|
|
|
audit_log_d_path(ab, " exe=", &mm->exe_file->f_path);
|
2006-03-30 03:17:10 +02:00
|
|
|
up_read(&mm->mmap_sem);
|
2005-04-18 19:47:35 +02:00
|
|
|
}
|
2006-03-30 03:17:10 +02:00
|
|
|
audit_log_task_context(ab);
|
2005-04-18 19:47:35 +02:00
|
|
|
}
|
|
|
|
|
2012-06-14 19:04:35 +02:00
|
|
|
EXPORT_SYMBOL(audit_log_task_info);
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
static int audit_log_pid_context(struct audit_context *context, pid_t pid,
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t auid, kuid_t uid, unsigned int sessionid,
|
2008-01-08 16:06:53 +01:00
|
|
|
u32 sid, char *comm)
|
2007-03-30 00:01:04 +02:00
|
|
|
{
|
|
|
|
struct audit_buffer *ab;
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
char *ctx = NULL;
|
2007-03-30 00:01:04 +02:00
|
|
|
u32 len;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_OBJ_PID);
|
|
|
|
if (!ab)
|
2008-01-07 20:01:18 +01:00
|
|
|
return rc;
|
2007-03-30 00:01:04 +02:00
|
|
|
|
2012-09-11 07:39:43 +02:00
|
|
|
audit_log_format(ab, "opid=%d oauid=%d ouid=%d oses=%d", pid,
|
|
|
|
from_kuid(&init_user_ns, auid),
|
2012-02-08 01:53:48 +01:00
|
|
|
from_kuid(&init_user_ns, uid), sessionid);
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
if (security_secid_to_secctx(sid, &ctx, &len)) {
|
2008-01-07 19:40:17 +01:00
|
|
|
audit_log_format(ab, " obj=(none)");
|
2007-03-30 00:01:04 +02:00
|
|
|
rc = 1;
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
} else {
|
|
|
|
audit_log_format(ab, " obj=%s", ctx);
|
|
|
|
security_release_secctx(ctx, len);
|
|
|
|
}
|
2008-01-07 19:40:17 +01:00
|
|
|
audit_log_format(ab, " ocomm=");
|
|
|
|
audit_log_untrustedstring(ab, comm);
|
2007-03-30 00:01:04 +02:00
|
|
|
audit_log_end(ab);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-01-07 20:31:58 +01:00
|
|
|
/*
|
|
|
|
* to_send and len_sent accounting are very loose estimates. We aren't
|
|
|
|
* really worried about a hard cap to MAX_EXECVE_AUDIT_LEN so much as being
|
2011-03-31 03:57:33 +02:00
|
|
|
* within about 500 bytes (next page boundary)
|
2008-01-07 20:31:58 +01:00
|
|
|
*
|
|
|
|
* why snprintf? an int is up to 12 digits long. if we just assumed when
|
|
|
|
* logging that a[%d]= was going to be 16 characters long we would be wasting
|
|
|
|
* space in every audit message. In one 7500 byte message we can log up to
|
|
|
|
* about 1000 min size arguments. That comes down to about 50% waste of space
|
|
|
|
* if we didn't do the snprintf to find out how long arg_num_len was.
|
|
|
|
*/
|
|
|
|
static int audit_log_single_execve_arg(struct audit_context *context,
|
|
|
|
struct audit_buffer **ab,
|
|
|
|
int arg_num,
|
|
|
|
size_t *len_sent,
|
|
|
|
const char __user *p,
|
|
|
|
char *buf)
|
2007-07-19 10:48:15 +02:00
|
|
|
{
|
2008-01-07 20:31:58 +01:00
|
|
|
char arg_num_len_buf[12];
|
|
|
|
const char __user *tmp_p = p;
|
2009-06-11 20:31:34 +02:00
|
|
|
/* how many digits are in arg_num? 5 is the length of ' a=""' */
|
|
|
|
size_t arg_num_len = snprintf(arg_num_len_buf, 12, "%d", arg_num) + 5;
|
2008-01-07 20:31:58 +01:00
|
|
|
size_t len, len_left, to_send;
|
|
|
|
size_t max_execve_audit_len = MAX_EXECVE_AUDIT_LEN;
|
|
|
|
unsigned int i, has_cntl = 0, too_long = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* strnlen_user includes the null we don't want to send */
|
|
|
|
len_left = len = strnlen_user(p, MAX_ARG_STRLEN) - 1;
|
2007-07-19 10:48:15 +02:00
|
|
|
|
2008-01-07 20:31:58 +01:00
|
|
|
/*
|
|
|
|
* We just created this mm, if we can't find the strings
|
|
|
|
* we just copied into it something is _very_ wrong. Similar
|
|
|
|
* for strings that are too long, we should not have created
|
|
|
|
* any.
|
|
|
|
*/
|
2008-02-19 00:23:16 +01:00
|
|
|
if (unlikely((len == -1) || len > MAX_ARG_STRLEN - 1)) {
|
2008-01-07 20:31:58 +01:00
|
|
|
WARN_ON(1);
|
|
|
|
send_sig(SIGKILL, current, 0);
|
2008-02-19 00:23:16 +01:00
|
|
|
return -1;
|
2008-01-07 20:31:58 +01:00
|
|
|
}
|
2007-07-28 00:55:18 +02:00
|
|
|
|
2008-01-07 20:31:58 +01:00
|
|
|
/* walk the whole argument looking for non-ascii chars */
|
|
|
|
do {
|
|
|
|
if (len_left > MAX_EXECVE_AUDIT_LEN)
|
|
|
|
to_send = MAX_EXECVE_AUDIT_LEN;
|
|
|
|
else
|
|
|
|
to_send = len_left;
|
|
|
|
ret = copy_from_user(buf, tmp_p, to_send);
|
2007-07-19 10:48:15 +02:00
|
|
|
/*
|
2008-01-07 20:31:58 +01:00
|
|
|
* There is no reason for this copy to be short. We just
|
|
|
|
* copied them here, and the mm hasn't been exposed to user-
|
|
|
|
* space yet.
|
2007-07-19 10:48:15 +02:00
|
|
|
*/
|
2008-01-07 20:31:58 +01:00
|
|
|
if (ret) {
|
2007-07-19 10:48:15 +02:00
|
|
|
WARN_ON(1);
|
|
|
|
send_sig(SIGKILL, current, 0);
|
2008-02-19 00:23:16 +01:00
|
|
|
return -1;
|
2007-07-19 10:48:15 +02:00
|
|
|
}
|
2008-01-07 20:31:58 +01:00
|
|
|
buf[to_send] = '\0';
|
|
|
|
has_cntl = audit_string_contains_control(buf, to_send);
|
|
|
|
if (has_cntl) {
|
|
|
|
/*
|
|
|
|
* hex messages get logged as 2 bytes, so we can only
|
|
|
|
* send half as much in each message
|
|
|
|
*/
|
|
|
|
max_execve_audit_len = MAX_EXECVE_AUDIT_LEN / 2;
|
2007-07-19 10:48:15 +02:00
|
|
|
break;
|
|
|
|
}
|
2008-01-07 20:31:58 +01:00
|
|
|
len_left -= to_send;
|
|
|
|
tmp_p += to_send;
|
|
|
|
} while (len_left > 0);
|
|
|
|
|
|
|
|
len_left = len;
|
|
|
|
|
|
|
|
if (len > max_execve_audit_len)
|
|
|
|
too_long = 1;
|
|
|
|
|
|
|
|
/* rewalk the argument actually logging the message */
|
|
|
|
for (i = 0; len_left > 0; i++) {
|
|
|
|
int room_left;
|
|
|
|
|
|
|
|
if (len_left > max_execve_audit_len)
|
|
|
|
to_send = max_execve_audit_len;
|
|
|
|
else
|
|
|
|
to_send = len_left;
|
|
|
|
|
|
|
|
/* do we have space left to send this argument in this ab? */
|
|
|
|
room_left = MAX_EXECVE_AUDIT_LEN - arg_num_len - *len_sent;
|
|
|
|
if (has_cntl)
|
|
|
|
room_left -= (to_send * 2);
|
|
|
|
else
|
|
|
|
room_left -= to_send;
|
|
|
|
if (room_left < 0) {
|
|
|
|
*len_sent = 0;
|
|
|
|
audit_log_end(*ab);
|
|
|
|
*ab = audit_log_start(context, GFP_KERNEL, AUDIT_EXECVE);
|
|
|
|
if (!*ab)
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-19 10:48:15 +02:00
|
|
|
|
|
|
|
/*
|
2008-01-07 20:31:58 +01:00
|
|
|
* first record needs to say how long the original string was
|
|
|
|
* so we can be sure nothing was lost.
|
|
|
|
*/
|
|
|
|
if ((i == 0) && (too_long))
|
2009-01-09 16:44:16 +01:00
|
|
|
audit_log_format(*ab, " a%d_len=%zu", arg_num,
|
2008-01-07 20:31:58 +01:00
|
|
|
has_cntl ? 2*len : len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* normally arguments are small enough to fit and we already
|
|
|
|
* filled buf above when we checked for control characters
|
|
|
|
* so don't bother with another copy_from_user
|
2007-07-19 10:48:15 +02:00
|
|
|
*/
|
2008-01-07 20:31:58 +01:00
|
|
|
if (len >= max_execve_audit_len)
|
|
|
|
ret = copy_from_user(buf, p, to_send);
|
|
|
|
else
|
|
|
|
ret = 0;
|
2007-07-28 00:55:18 +02:00
|
|
|
if (ret) {
|
2007-07-19 10:48:15 +02:00
|
|
|
WARN_ON(1);
|
|
|
|
send_sig(SIGKILL, current, 0);
|
2008-02-19 00:23:16 +01:00
|
|
|
return -1;
|
2007-07-19 10:48:15 +02:00
|
|
|
}
|
2008-01-07 20:31:58 +01:00
|
|
|
buf[to_send] = '\0';
|
|
|
|
|
|
|
|
/* actually log it */
|
2009-01-09 16:44:16 +01:00
|
|
|
audit_log_format(*ab, " a%d", arg_num);
|
2008-01-07 20:31:58 +01:00
|
|
|
if (too_long)
|
|
|
|
audit_log_format(*ab, "[%d]", i);
|
|
|
|
audit_log_format(*ab, "=");
|
|
|
|
if (has_cntl)
|
2008-04-18 16:12:59 +02:00
|
|
|
audit_log_n_hex(*ab, buf, to_send);
|
2008-01-07 20:31:58 +01:00
|
|
|
else
|
2009-06-11 20:31:37 +02:00
|
|
|
audit_log_string(*ab, buf);
|
2008-01-07 20:31:58 +01:00
|
|
|
|
|
|
|
p += to_send;
|
|
|
|
len_left -= to_send;
|
|
|
|
*len_sent += arg_num_len;
|
|
|
|
if (has_cntl)
|
|
|
|
*len_sent += to_send * 2;
|
|
|
|
else
|
|
|
|
*len_sent += to_send;
|
|
|
|
}
|
|
|
|
/* include the null we didn't log */
|
|
|
|
return len + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audit_log_execve_info(struct audit_context *context,
|
|
|
|
struct audit_buffer **ab,
|
|
|
|
struct audit_aux_data_execve *axi)
|
|
|
|
{
|
2011-12-21 00:39:41 +01:00
|
|
|
int i, len;
|
|
|
|
size_t len_sent = 0;
|
2008-01-07 20:31:58 +01:00
|
|
|
const char __user *p;
|
|
|
|
char *buf;
|
2007-07-19 10:48:15 +02:00
|
|
|
|
2008-01-07 20:31:58 +01:00
|
|
|
if (axi->mm != current->mm)
|
|
|
|
return; /* execve failed, no additional info */
|
|
|
|
|
|
|
|
p = (const char __user *)axi->mm->arg_start;
|
2007-07-19 10:48:15 +02:00
|
|
|
|
2009-01-09 16:44:16 +01:00
|
|
|
audit_log_format(*ab, "argc=%d", axi->argc);
|
2008-01-07 20:31:58 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we need some kernel buffer to hold the userspace args. Just
|
|
|
|
* allocate one big one rather than allocating one of the right size
|
|
|
|
* for every single argument inside audit_log_single_execve_arg()
|
|
|
|
* should be <8k allocation so should be pretty safe.
|
|
|
|
*/
|
|
|
|
buf = kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL);
|
|
|
|
if (!buf) {
|
|
|
|
audit_panic("out of memory for argv string\n");
|
|
|
|
return;
|
2007-07-19 10:48:15 +02:00
|
|
|
}
|
2008-01-07 20:31:58 +01:00
|
|
|
|
|
|
|
for (i = 0; i < axi->argc; i++) {
|
|
|
|
len = audit_log_single_execve_arg(context, ab, i,
|
|
|
|
&len_sent, p, buf);
|
|
|
|
if (len <= 0)
|
|
|
|
break;
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
kfree(buf);
|
2007-07-19 10:48:15 +02:00
|
|
|
}
|
|
|
|
|
2008-11-11 11:48:14 +01:00
|
|
|
static void audit_log_cap(struct audit_buffer *ab, char *prefix, kernel_cap_t *cap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
audit_log_format(ab, " %s=", prefix);
|
|
|
|
CAP_FOR_EACH_U32(i) {
|
|
|
|
audit_log_format(ab, "%08x", cap->cap[(_KERNEL_CAPABILITY_U32S-1) - i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audit_log_fcaps(struct audit_buffer *ab, struct audit_names *name)
|
|
|
|
{
|
|
|
|
kernel_cap_t *perm = &name->fcap.permitted;
|
|
|
|
kernel_cap_t *inh = &name->fcap.inheritable;
|
|
|
|
int log = 0;
|
|
|
|
|
|
|
|
if (!cap_isclear(*perm)) {
|
|
|
|
audit_log_cap(ab, "cap_fp", perm);
|
|
|
|
log = 1;
|
|
|
|
}
|
|
|
|
if (!cap_isclear(*inh)) {
|
|
|
|
audit_log_cap(ab, "cap_fi", inh);
|
|
|
|
log = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log)
|
|
|
|
audit_log_format(ab, " cap_fe=%d cap_fver=%x", name->fcap.fE, name->fcap_ver);
|
|
|
|
}
|
|
|
|
|
2008-12-10 09:40:06 +01:00
|
|
|
static void show_special(struct audit_context *context, int *call_panic)
|
2008-12-10 09:16:51 +01:00
|
|
|
{
|
|
|
|
struct audit_buffer *ab;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, context->type);
|
|
|
|
if (!ab)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (context->type) {
|
|
|
|
case AUDIT_SOCKETCALL: {
|
|
|
|
int nargs = context->socketcall.nargs;
|
|
|
|
audit_log_format(ab, "nargs=%d", nargs);
|
|
|
|
for (i = 0; i < nargs; i++)
|
|
|
|
audit_log_format(ab, " a%d=%lx", i,
|
|
|
|
context->socketcall.args[i]);
|
|
|
|
break; }
|
2008-12-10 09:40:06 +01:00
|
|
|
case AUDIT_IPC: {
|
|
|
|
u32 osid = context->ipc.osid;
|
|
|
|
|
2011-07-27 20:03:22 +02:00
|
|
|
audit_log_format(ab, "ouid=%u ogid=%u mode=%#ho",
|
2012-02-08 01:53:48 +01:00
|
|
|
from_kuid(&init_user_ns, context->ipc.uid),
|
|
|
|
from_kgid(&init_user_ns, context->ipc.gid),
|
|
|
|
context->ipc.mode);
|
2008-12-10 09:40:06 +01:00
|
|
|
if (osid) {
|
|
|
|
char *ctx = NULL;
|
|
|
|
u32 len;
|
|
|
|
if (security_secid_to_secctx(osid, &ctx, &len)) {
|
|
|
|
audit_log_format(ab, " osid=%u", osid);
|
|
|
|
*call_panic = 1;
|
|
|
|
} else {
|
|
|
|
audit_log_format(ab, " obj=%s", ctx);
|
|
|
|
security_release_secctx(ctx, len);
|
|
|
|
}
|
|
|
|
}
|
2008-12-10 09:47:15 +01:00
|
|
|
if (context->ipc.has_perm) {
|
|
|
|
audit_log_end(ab);
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL,
|
|
|
|
AUDIT_IPC_SET_PERM);
|
|
|
|
audit_log_format(ab,
|
2011-07-27 20:03:22 +02:00
|
|
|
"qbytes=%lx ouid=%u ogid=%u mode=%#ho",
|
2008-12-10 09:47:15 +01:00
|
|
|
context->ipc.qbytes,
|
|
|
|
context->ipc.perm_uid,
|
|
|
|
context->ipc.perm_gid,
|
|
|
|
context->ipc.perm_mode);
|
|
|
|
if (!ab)
|
|
|
|
return;
|
|
|
|
}
|
2008-12-10 09:40:06 +01:00
|
|
|
break; }
|
2008-12-14 10:02:26 +01:00
|
|
|
case AUDIT_MQ_OPEN: {
|
|
|
|
audit_log_format(ab,
|
2011-07-26 11:26:10 +02:00
|
|
|
"oflag=0x%x mode=%#ho mq_flags=0x%lx mq_maxmsg=%ld "
|
2008-12-14 10:02:26 +01:00
|
|
|
"mq_msgsize=%ld mq_curmsgs=%ld",
|
|
|
|
context->mq_open.oflag, context->mq_open.mode,
|
|
|
|
context->mq_open.attr.mq_flags,
|
|
|
|
context->mq_open.attr.mq_maxmsg,
|
|
|
|
context->mq_open.attr.mq_msgsize,
|
|
|
|
context->mq_open.attr.mq_curmsgs);
|
|
|
|
break; }
|
2008-12-14 09:46:48 +01:00
|
|
|
case AUDIT_MQ_SENDRECV: {
|
|
|
|
audit_log_format(ab,
|
|
|
|
"mqdes=%d msg_len=%zd msg_prio=%u "
|
|
|
|
"abs_timeout_sec=%ld abs_timeout_nsec=%ld",
|
|
|
|
context->mq_sendrecv.mqdes,
|
|
|
|
context->mq_sendrecv.msg_len,
|
|
|
|
context->mq_sendrecv.msg_prio,
|
|
|
|
context->mq_sendrecv.abs_timeout.tv_sec,
|
|
|
|
context->mq_sendrecv.abs_timeout.tv_nsec);
|
|
|
|
break; }
|
2008-12-10 13:16:12 +01:00
|
|
|
case AUDIT_MQ_NOTIFY: {
|
|
|
|
audit_log_format(ab, "mqdes=%d sigev_signo=%d",
|
|
|
|
context->mq_notify.mqdes,
|
|
|
|
context->mq_notify.sigev_signo);
|
|
|
|
break; }
|
2008-12-10 12:58:59 +01:00
|
|
|
case AUDIT_MQ_GETSETATTR: {
|
|
|
|
struct mq_attr *attr = &context->mq_getsetattr.mqstat;
|
|
|
|
audit_log_format(ab,
|
|
|
|
"mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
|
|
|
|
"mq_curmsgs=%ld ",
|
|
|
|
context->mq_getsetattr.mqdes,
|
|
|
|
attr->mq_flags, attr->mq_maxmsg,
|
|
|
|
attr->mq_msgsize, attr->mq_curmsgs);
|
|
|
|
break; }
|
2009-01-04 20:52:57 +01:00
|
|
|
case AUDIT_CAPSET: {
|
|
|
|
audit_log_format(ab, "pid=%d", context->capset.pid);
|
|
|
|
audit_log_cap(ab, "cap_pi", &context->capset.cap.inheritable);
|
|
|
|
audit_log_cap(ab, "cap_pp", &context->capset.cap.permitted);
|
|
|
|
audit_log_cap(ab, "cap_pe", &context->capset.cap.effective);
|
|
|
|
break; }
|
2010-10-30 08:54:44 +02:00
|
|
|
case AUDIT_MMAP: {
|
|
|
|
audit_log_format(ab, "fd=%d flags=0x%x", context->mmap.fd,
|
|
|
|
context->mmap.flags);
|
|
|
|
break; }
|
2008-12-10 09:16:51 +01:00
|
|
|
}
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
static void audit_log_name(struct audit_context *context, struct audit_names *n,
|
|
|
|
int record_num, int *call_panic)
|
|
|
|
{
|
|
|
|
struct audit_buffer *ab;
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_PATH);
|
|
|
|
if (!ab)
|
|
|
|
return; /* audit_panic has been called */
|
|
|
|
|
|
|
|
audit_log_format(ab, "item=%d", record_num);
|
|
|
|
|
|
|
|
if (n->name) {
|
|
|
|
switch (n->name_len) {
|
|
|
|
case AUDIT_NAME_FULL:
|
|
|
|
/* log the full path */
|
|
|
|
audit_log_format(ab, " name=");
|
|
|
|
audit_log_untrustedstring(ab, n->name);
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
/* name was specified as a relative path and the
|
|
|
|
* directory component is the cwd */
|
2012-01-06 23:07:10 +01:00
|
|
|
audit_log_d_path(ab, " name=", &context->pwd);
|
2012-01-03 20:23:05 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* log the name's directory component */
|
|
|
|
audit_log_format(ab, " name=");
|
|
|
|
audit_log_n_untrustedstring(ab, n->name,
|
|
|
|
n->name_len);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
audit_log_format(ab, " name=(null)");
|
|
|
|
|
|
|
|
if (n->ino != (unsigned long)-1) {
|
|
|
|
audit_log_format(ab, " inode=%lu"
|
|
|
|
" dev=%02x:%02x mode=%#ho"
|
|
|
|
" ouid=%u ogid=%u rdev=%02x:%02x",
|
|
|
|
n->ino,
|
|
|
|
MAJOR(n->dev),
|
|
|
|
MINOR(n->dev),
|
|
|
|
n->mode,
|
2012-02-08 01:53:48 +01:00
|
|
|
from_kuid(&init_user_ns, n->uid),
|
|
|
|
from_kgid(&init_user_ns, n->gid),
|
2012-01-03 20:23:05 +01:00
|
|
|
MAJOR(n->rdev),
|
|
|
|
MINOR(n->rdev));
|
|
|
|
}
|
|
|
|
if (n->osid != 0) {
|
|
|
|
char *ctx = NULL;
|
|
|
|
u32 len;
|
|
|
|
if (security_secid_to_secctx(
|
|
|
|
n->osid, &ctx, &len)) {
|
|
|
|
audit_log_format(ab, " osid=%u", n->osid);
|
|
|
|
*call_panic = 2;
|
|
|
|
} else {
|
|
|
|
audit_log_format(ab, " obj=%s", ctx);
|
|
|
|
security_release_secctx(ctx, len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
audit_log_fcaps(ab, n);
|
|
|
|
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
static void audit_log_exit(struct audit_context *context, struct task_struct *tsk)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-31 22:22:49 +02:00
|
|
|
int i, call_panic = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct audit_buffer *ab;
|
2005-05-26 13:04:57 +02:00
|
|
|
struct audit_aux_data *aux;
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
/* tsk == current */
|
2006-07-16 12:43:48 +02:00
|
|
|
context->personality = tsk->personality;
|
2006-03-30 03:17:10 +02:00
|
|
|
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_SYSCALL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ab)
|
|
|
|
return; /* audit_panic has been called */
|
2005-05-23 22:35:28 +02:00
|
|
|
audit_log_format(ab, "arch=%x syscall=%d",
|
|
|
|
context->arch, context->major);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (context->personality != PER_LINUX)
|
|
|
|
audit_log_format(ab, " per=%lx", context->personality);
|
|
|
|
if (context->return_valid)
|
2007-10-18 12:06:09 +02:00
|
|
|
audit_log_format(ab, " success=%s exit=%ld",
|
2005-04-29 17:08:28 +02:00
|
|
|
(context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
|
|
|
|
context->return_code);
|
2006-09-29 11:01:41 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
audit_log_format(ab,
|
2012-06-14 19:04:35 +02:00
|
|
|
" a0=%lx a1=%lx a2=%lx a3=%lx items=%d",
|
|
|
|
context->argv[0],
|
|
|
|
context->argv[1],
|
|
|
|
context->argv[2],
|
|
|
|
context->argv[3],
|
|
|
|
context->name_count);
|
2006-09-29 11:01:41 +02:00
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
audit_log_task_info(ab, tsk);
|
2009-06-11 20:31:37 +02:00
|
|
|
audit_log_key(ab, context->filterkey);
|
2005-04-17 00:20:36 +02:00
|
|
|
audit_log_end(ab);
|
|
|
|
|
2005-05-26 13:04:57 +02:00
|
|
|
for (aux = context->aux; aux; aux = aux->next) {
|
2005-05-13 19:17:42 +02:00
|
|
|
|
2006-03-30 03:17:10 +02:00
|
|
|
ab = audit_log_start(context, GFP_KERNEL, aux->type);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ab)
|
|
|
|
continue; /* audit_panic has been called */
|
|
|
|
|
|
|
|
switch (aux->type) {
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2006-04-26 20:04:08 +02:00
|
|
|
case AUDIT_EXECVE: {
|
|
|
|
struct audit_aux_data_execve *axi = (void *)aux;
|
2008-01-07 20:31:58 +01:00
|
|
|
audit_log_execve_info(context, &ab, axi);
|
2006-04-26 20:04:08 +02:00
|
|
|
break; }
|
2006-04-02 23:07:33 +02:00
|
|
|
|
2008-11-11 11:48:18 +01:00
|
|
|
case AUDIT_BPRM_FCAPS: {
|
|
|
|
struct audit_aux_data_bprm_fcaps *axs = (void *)aux;
|
|
|
|
audit_log_format(ab, "fver=%x", axs->fcap_ver);
|
|
|
|
audit_log_cap(ab, "fp", &axs->fcap.permitted);
|
|
|
|
audit_log_cap(ab, "fi", &axs->fcap.inheritable);
|
|
|
|
audit_log_format(ab, " fe=%d", axs->fcap.fE);
|
|
|
|
audit_log_cap(ab, "old_pp", &axs->old_pcap.permitted);
|
|
|
|
audit_log_cap(ab, "old_pi", &axs->old_pcap.inheritable);
|
|
|
|
audit_log_cap(ab, "old_pe", &axs->old_pcap.effective);
|
|
|
|
audit_log_cap(ab, "new_pp", &axs->new_pcap.permitted);
|
|
|
|
audit_log_cap(ab, "new_pi", &axs->new_pcap.inheritable);
|
|
|
|
audit_log_cap(ab, "new_pe", &axs->new_pcap.effective);
|
|
|
|
break; }
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
|
2008-12-10 09:16:51 +01:00
|
|
|
if (context->type)
|
2008-12-10 09:40:06 +01:00
|
|
|
show_special(context, &call_panic);
|
2008-12-10 09:16:51 +01:00
|
|
|
|
2008-12-14 10:57:47 +01:00
|
|
|
if (context->fds[0] >= 0) {
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_FD_PAIR);
|
|
|
|
if (ab) {
|
|
|
|
audit_log_format(ab, "fd0=%d fd1=%d",
|
|
|
|
context->fds[0], context->fds[1]);
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-10 01:50:34 +01:00
|
|
|
if (context->sockaddr_len) {
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_SOCKADDR);
|
|
|
|
if (ab) {
|
|
|
|
audit_log_format(ab, "saddr=");
|
|
|
|
audit_log_n_hex(ab, (void *)context->sockaddr,
|
|
|
|
context->sockaddr_len);
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
for (aux = context->aux_pids; aux; aux = aux->next) {
|
|
|
|
struct audit_aux_data_pids *axs = (void *)aux;
|
|
|
|
|
|
|
|
for (i = 0; i < axs->pid_count; i++)
|
|
|
|
if (audit_log_pid_context(context, axs->target_pid[i],
|
2008-01-07 19:40:17 +01:00
|
|
|
axs->target_auid[i],
|
|
|
|
axs->target_uid[i],
|
2008-01-08 16:06:53 +01:00
|
|
|
axs->target_sessionid[i],
|
2008-01-07 19:40:17 +01:00
|
|
|
axs->target_sid[i],
|
|
|
|
axs->target_comm[i]))
|
2007-03-30 00:01:04 +02:00
|
|
|
call_panic = 1;
|
2007-03-20 18:58:35 +01:00
|
|
|
}
|
|
|
|
|
2007-03-30 00:01:04 +02:00
|
|
|
if (context->target_pid &&
|
|
|
|
audit_log_pid_context(context, context->target_pid,
|
2008-01-07 19:40:17 +01:00
|
|
|
context->target_auid, context->target_uid,
|
2008-01-08 16:06:53 +01:00
|
|
|
context->target_sessionid,
|
2008-01-07 19:40:17 +01:00
|
|
|
context->target_sid, context->target_comm))
|
2007-03-30 00:01:04 +02:00
|
|
|
call_panic = 1;
|
|
|
|
|
2008-02-15 04:38:33 +01:00
|
|
|
if (context->pwd.dentry && context->pwd.mnt) {
|
2006-03-30 03:17:10 +02:00
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_CWD);
|
2005-05-27 13:17:28 +02:00
|
|
|
if (ab) {
|
2012-01-06 23:07:10 +01:00
|
|
|
audit_log_d_path(ab, " cwd=", &context->pwd);
|
2005-05-27 13:17:28 +02:00
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
|
|
|
}
|
2005-11-03 17:00:25 +01:00
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
i = 0;
|
|
|
|
list_for_each_entry(n, &context->names_list, list)
|
|
|
|
audit_log_name(context, n, i++, &call_panic);
|
2008-01-07 19:49:15 +01:00
|
|
|
|
|
|
|
/* Send end of event record to help user space know we are finished */
|
|
|
|
ab = audit_log_start(context, GFP_KERNEL, AUDIT_EOE);
|
|
|
|
if (ab)
|
|
|
|
audit_log_end(ab);
|
2006-03-31 22:22:49 +02:00
|
|
|
if (call_panic)
|
|
|
|
audit_panic("error converting sid to string");
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_free - free a per-task audit context
|
|
|
|
* @tsk: task whose audit context block to free
|
|
|
|
*
|
2006-03-30 03:30:19 +02:00
|
|
|
* Called from copy_process and do_exit
|
2005-09-13 21:47:11 +02:00
|
|
|
*/
|
2012-01-03 20:23:07 +01:00
|
|
|
void __audit_free(struct task_struct *tsk)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context;
|
|
|
|
|
|
|
|
context = audit_get_context(tsk, 0, 0);
|
2012-01-03 20:23:06 +01:00
|
|
|
if (!context)
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Check for system calls that do not go through the exit
|
2007-10-18 12:06:09 +02:00
|
|
|
* function (e.g., exit_group), then free context block.
|
|
|
|
* We use GFP_ATOMIC here because we might be doing this
|
2005-07-13 23:47:07 +02:00
|
|
|
* in the context of the idle thread */
|
2006-03-30 03:17:10 +02:00
|
|
|
/* that can happen only if we are called from do_exit() */
|
2008-12-15 05:45:27 +01:00
|
|
|
if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
|
2006-03-30 03:17:10 +02:00
|
|
|
audit_log_exit(context, tsk);
|
2009-06-24 06:02:38 +02:00
|
|
|
if (!list_empty(&context->killed_trees))
|
|
|
|
audit_kill_trees(&context->killed_trees);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
audit_free_context(context);
|
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_syscall_entry - fill in an audit record at syscall entry
|
|
|
|
* @arch: architecture type
|
|
|
|
* @major: major syscall type (function)
|
|
|
|
* @a1: additional syscall register 1
|
|
|
|
* @a2: additional syscall register 2
|
|
|
|
* @a3: additional syscall register 3
|
|
|
|
* @a4: additional syscall register 4
|
|
|
|
*
|
|
|
|
* Fill in audit context at syscall entry. This only happens if the
|
2005-04-17 00:20:36 +02:00
|
|
|
* audit context was created when the task was created and the state or
|
|
|
|
* filters demand the audit context be built. If the state from the
|
|
|
|
* per-task filter or from the per-syscall filter is AUDIT_RECORD_CONTEXT,
|
|
|
|
* then the record will be written at syscall exit time (otherwise, it
|
|
|
|
* will only be written if another part of the kernel requests that it
|
2005-09-13 21:47:11 +02:00
|
|
|
* be written).
|
|
|
|
*/
|
2012-01-03 20:23:06 +01:00
|
|
|
void __audit_syscall_entry(int arch, int major,
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long a1, unsigned long a2,
|
|
|
|
unsigned long a3, unsigned long a4)
|
|
|
|
{
|
2006-03-30 03:23:36 +02:00
|
|
|
struct task_struct *tsk = current;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct audit_context *context = tsk->audit_context;
|
|
|
|
enum audit_state state;
|
|
|
|
|
2012-01-03 20:23:06 +01:00
|
|
|
if (!context)
|
2008-06-24 00:37:04 +02:00
|
|
|
return;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/*
|
|
|
|
* This happens only on certain architectures that make system
|
2005-04-17 00:20:36 +02:00
|
|
|
* calls in kernel_thread via the entry.S interface, instead of
|
|
|
|
* with direct calls. (If you are porting to a new
|
|
|
|
* architecture, hitting this condition can indicate that you
|
|
|
|
* got the _exit/_leave calls backward in entry.S.)
|
|
|
|
*
|
|
|
|
* i386 no
|
|
|
|
* x86_64 no
|
2006-01-23 17:58:20 +01:00
|
|
|
* ppc64 yes (see arch/powerpc/platforms/iseries/misc.S)
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* This also happens with vm86 emulation in a non-nested manner
|
|
|
|
* (entries without exits), so this case must be caught.
|
|
|
|
*/
|
|
|
|
if (context->in_syscall) {
|
|
|
|
struct audit_context *newctx;
|
|
|
|
|
|
|
|
#if AUDIT_DEBUG
|
|
|
|
printk(KERN_ERR
|
|
|
|
"audit(:%d) pid=%d in syscall=%d;"
|
|
|
|
" entering syscall=%d\n",
|
|
|
|
context->serial, tsk->pid, context->major, major);
|
|
|
|
#endif
|
|
|
|
newctx = audit_alloc_context(context->state);
|
|
|
|
if (newctx) {
|
|
|
|
newctx->previous = context;
|
|
|
|
context = newctx;
|
|
|
|
tsk->audit_context = newctx;
|
|
|
|
} else {
|
|
|
|
/* If we can't alloc a new context, the best we
|
|
|
|
* can do is to leak memory (any pending putname
|
|
|
|
* will be lost). The only other alternative is
|
|
|
|
* to abandon auditing. */
|
|
|
|
audit_zero_context(context, context->state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BUG_ON(context->in_syscall || context->name_count);
|
|
|
|
|
|
|
|
if (!audit_enabled)
|
|
|
|
return;
|
|
|
|
|
2005-04-29 17:08:28 +02:00
|
|
|
context->arch = arch;
|
2005-04-17 00:20:36 +02:00
|
|
|
context->major = major;
|
|
|
|
context->argv[0] = a1;
|
|
|
|
context->argv[1] = a2;
|
|
|
|
context->argv[2] = a3;
|
|
|
|
context->argv[3] = a4;
|
|
|
|
|
|
|
|
state = context->state;
|
2006-08-03 16:59:26 +02:00
|
|
|
context->dummy = !audit_n_rules;
|
2008-12-15 05:45:27 +01:00
|
|
|
if (!context->dummy && state == AUDIT_BUILD_CONTEXT) {
|
|
|
|
context->prio = 0;
|
2005-06-19 20:35:50 +02:00
|
|
|
state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
|
2008-12-15 05:45:27 +01:00
|
|
|
}
|
2012-01-03 20:23:06 +01:00
|
|
|
if (state == AUDIT_DISABLED)
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
2005-07-18 20:24:46 +02:00
|
|
|
context->serial = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
context->ctime = CURRENT_TIME;
|
|
|
|
context->in_syscall = 1;
|
2008-12-15 05:45:27 +01:00
|
|
|
context->current_state = state;
|
2006-09-29 06:08:50 +02:00
|
|
|
context->ppid = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_syscall_exit - deallocate audit context after a system call
|
2012-01-21 20:02:24 +01:00
|
|
|
* @success: success value of the syscall
|
|
|
|
* @return_code: return value of the syscall
|
2005-09-13 21:47:11 +02:00
|
|
|
*
|
|
|
|
* Tear down after system call. If the audit context has been marked as
|
2005-04-17 00:20:36 +02:00
|
|
|
* auditable (either because of the AUDIT_RECORD_CONTEXT state from
|
2012-01-21 20:02:24 +01:00
|
|
|
* filtering, or because some other part of the kernel wrote an audit
|
2005-04-17 00:20:36 +02:00
|
|
|
* message), then write out the syscall information. In call cases,
|
2005-09-13 21:47:11 +02:00
|
|
|
* free the names stored from getname().
|
|
|
|
*/
|
2012-01-03 20:23:06 +01:00
|
|
|
void __audit_syscall_exit(int success, long return_code)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-30 03:23:36 +02:00
|
|
|
struct task_struct *tsk = current;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct audit_context *context;
|
|
|
|
|
2012-01-03 20:23:06 +01:00
|
|
|
if (success)
|
|
|
|
success = AUDITSC_SUCCESS;
|
|
|
|
else
|
|
|
|
success = AUDITSC_FAILURE;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-01-03 20:23:06 +01:00
|
|
|
context = audit_get_context(tsk, success, return_code);
|
2012-01-03 20:23:06 +01:00
|
|
|
if (!context)
|
2006-03-30 03:26:24 +02:00
|
|
|
return;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-15 05:45:27 +01:00
|
|
|
if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
|
2006-03-30 03:17:10 +02:00
|
|
|
audit_log_exit(context, tsk);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
context->in_syscall = 0;
|
2008-12-15 05:45:27 +01:00
|
|
|
context->prio = context->state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
|
2005-04-29 17:08:28 +02:00
|
|
|
|
2009-06-24 06:02:38 +02:00
|
|
|
if (!list_empty(&context->killed_trees))
|
|
|
|
audit_kill_trees(&context->killed_trees);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (context->previous) {
|
|
|
|
struct audit_context *new_context = context->previous;
|
|
|
|
context->previous = NULL;
|
|
|
|
audit_free_context(context);
|
|
|
|
tsk->audit_context = new_context;
|
|
|
|
} else {
|
|
|
|
audit_free_names(context);
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
unroll_tree_refs(context, NULL, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
audit_free_aux(context);
|
2007-03-30 00:01:04 +02:00
|
|
|
context->aux = NULL;
|
|
|
|
context->aux_pids = NULL;
|
2007-03-20 18:58:35 +01:00
|
|
|
context->target_pid = 0;
|
2007-03-30 00:01:04 +02:00
|
|
|
context->target_sid = 0;
|
2008-12-10 01:50:34 +01:00
|
|
|
context->sockaddr_len = 0;
|
2008-12-10 09:16:51 +01:00
|
|
|
context->type = 0;
|
2008-12-14 10:57:47 +01:00
|
|
|
context->fds[0] = -1;
|
2008-12-16 09:51:22 +01:00
|
|
|
if (context->state != AUDIT_RECORD_CONTEXT) {
|
|
|
|
kfree(context->filterkey);
|
|
|
|
context->filterkey = NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
tsk->audit_context = context;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
static inline void handle_one(const struct inode *inode)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_AUDIT_TREE
|
|
|
|
struct audit_context *context;
|
|
|
|
struct audit_tree_refs *p;
|
|
|
|
struct audit_chunk *chunk;
|
|
|
|
int count;
|
2009-12-18 03:24:24 +01:00
|
|
|
if (likely(hlist_empty(&inode->i_fsnotify_marks)))
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
return;
|
|
|
|
context = current->audit_context;
|
|
|
|
p = context->trees;
|
|
|
|
count = context->tree_count;
|
|
|
|
rcu_read_lock();
|
|
|
|
chunk = audit_tree_lookup(inode);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (!chunk)
|
|
|
|
return;
|
|
|
|
if (likely(put_tree_ref(context, chunk)))
|
|
|
|
return;
|
|
|
|
if (unlikely(!grow_tree_refs(context))) {
|
2008-04-18 16:01:04 +02:00
|
|
|
printk(KERN_WARNING "out of memory, audit has lost a tree reference\n");
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
audit_set_auditable(context);
|
|
|
|
audit_put_chunk(chunk);
|
|
|
|
unroll_tree_refs(context, p, count);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
put_tree_ref(context, chunk);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_path(const struct dentry *dentry)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_AUDIT_TREE
|
|
|
|
struct audit_context *context;
|
|
|
|
struct audit_tree_refs *p;
|
|
|
|
const struct dentry *d, *parent;
|
|
|
|
struct audit_chunk *drop;
|
|
|
|
unsigned long seq;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
context = current->audit_context;
|
|
|
|
p = context->trees;
|
|
|
|
count = context->tree_count;
|
|
|
|
retry:
|
|
|
|
drop = NULL;
|
|
|
|
d = dentry;
|
|
|
|
rcu_read_lock();
|
|
|
|
seq = read_seqbegin(&rename_lock);
|
|
|
|
for(;;) {
|
|
|
|
struct inode *inode = d->d_inode;
|
2009-12-18 03:24:24 +01:00
|
|
|
if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
struct audit_chunk *chunk;
|
|
|
|
chunk = audit_tree_lookup(inode);
|
|
|
|
if (chunk) {
|
|
|
|
if (unlikely(!put_tree_ref(context, chunk))) {
|
|
|
|
drop = chunk;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parent = d->d_parent;
|
|
|
|
if (parent == d)
|
|
|
|
break;
|
|
|
|
d = parent;
|
|
|
|
}
|
|
|
|
if (unlikely(read_seqretry(&rename_lock, seq) || drop)) { /* in this order */
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (!drop) {
|
|
|
|
/* just a race with rename */
|
|
|
|
unroll_tree_refs(context, p, count);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
audit_put_chunk(drop);
|
|
|
|
if (grow_tree_refs(context)) {
|
|
|
|
/* OK, got more space */
|
|
|
|
unroll_tree_refs(context, p, count);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
/* too bad */
|
|
|
|
printk(KERN_WARNING
|
2008-04-18 16:01:04 +02:00
|
|
|
"out of memory, audit has lost a tree reference\n");
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
unroll_tree_refs(context, p, count);
|
|
|
|
audit_set_auditable(context);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
static struct audit_names *audit_alloc_name(struct audit_context *context)
|
|
|
|
{
|
|
|
|
struct audit_names *aname;
|
|
|
|
|
|
|
|
if (context->name_count < AUDIT_NAMES) {
|
|
|
|
aname = &context->preallocated_names[context->name_count];
|
|
|
|
memset(aname, 0, sizeof(*aname));
|
|
|
|
} else {
|
|
|
|
aname = kzalloc(sizeof(*aname), GFP_NOFS);
|
|
|
|
if (!aname)
|
|
|
|
return NULL;
|
|
|
|
aname->should_free = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
aname->ino = (unsigned long)-1;
|
|
|
|
list_add_tail(&aname->list, &context->names_list);
|
|
|
|
|
|
|
|
context->name_count++;
|
|
|
|
#if AUDIT_DEBUG
|
|
|
|
context->ino_count++;
|
|
|
|
#endif
|
|
|
|
return aname;
|
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_getname - add a name to the list
|
|
|
|
* @name: name to add
|
|
|
|
*
|
|
|
|
* Add a name to the list of audit names for this context.
|
|
|
|
* Called from fs/namei.c:getname().
|
|
|
|
*/
|
2006-05-18 22:01:30 +02:00
|
|
|
void __audit_getname(const char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!context->in_syscall) {
|
|
|
|
#if AUDIT_DEBUG == 2
|
|
|
|
printk(KERN_ERR "%s:%d(:%d): ignoring getname(%p)\n",
|
|
|
|
__FILE__, __LINE__, context->serial, name);
|
|
|
|
dump_stack();
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
2012-01-03 20:23:05 +01:00
|
|
|
|
|
|
|
n = audit_alloc_name(context);
|
|
|
|
if (!n)
|
|
|
|
return;
|
|
|
|
|
|
|
|
n->name = name;
|
|
|
|
n->name_len = AUDIT_NAME_FULL;
|
|
|
|
n->name_put = true;
|
|
|
|
|
2010-08-10 11:41:36 +02:00
|
|
|
if (!context->pwd.dentry)
|
|
|
|
get_fs_pwd(current->fs, &context->pwd);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/* audit_putname - intercept a putname request
|
|
|
|
* @name: name to intercept and delay for putname
|
|
|
|
*
|
|
|
|
* If we have stored the name from getname in the audit context,
|
|
|
|
* then we delay the putname until syscall exit.
|
|
|
|
* Called from include/linux/fs.h:putname().
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
void audit_putname(const char *name)
|
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
|
|
|
BUG_ON(!context);
|
|
|
|
if (!context->in_syscall) {
|
|
|
|
#if AUDIT_DEBUG == 2
|
|
|
|
printk(KERN_ERR "%s:%d(:%d): __putname(%p)\n",
|
|
|
|
__FILE__, __LINE__, context->serial, name);
|
|
|
|
if (context->name_count) {
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2005-04-17 00:20:36 +02:00
|
|
|
int i;
|
2012-01-03 20:23:05 +01:00
|
|
|
|
|
|
|
list_for_each_entry(n, &context->names_list, list)
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_ERR "name[%d] = %p = %s\n", i,
|
2012-01-03 20:23:05 +01:00
|
|
|
n->name, n->name ?: "(null)");
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
__putname(name);
|
|
|
|
}
|
|
|
|
#if AUDIT_DEBUG
|
|
|
|
else {
|
|
|
|
++context->put_count;
|
|
|
|
if (context->put_count > context->name_count) {
|
|
|
|
printk(KERN_ERR "%s:%d(:%d): major=%d"
|
|
|
|
" in_syscall=%d putname(%p) name_count=%d"
|
|
|
|
" put_count=%d\n",
|
|
|
|
__FILE__, __LINE__,
|
|
|
|
context->serial, context->major,
|
|
|
|
context->in_syscall, name, context->name_count,
|
|
|
|
context->put_count);
|
|
|
|
dump_stack();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-11-11 11:48:14 +01:00
|
|
|
static inline int audit_copy_fcaps(struct audit_names *name, const struct dentry *dentry)
|
|
|
|
{
|
|
|
|
struct cpu_vfs_cap_data caps;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (!dentry)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rc = get_vfs_caps_from_disk(dentry, &caps);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
name->fcap.permitted = caps.permitted;
|
|
|
|
name->fcap.inheritable = caps.inheritable;
|
|
|
|
name->fcap.fE = !!(caps.magic_etc & VFS_CAP_FLAGS_EFFECTIVE);
|
|
|
|
name->fcap_ver = (caps.magic_etc & VFS_CAP_REVISION_MASK) >> VFS_CAP_REVISION_SHIFT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-13 19:16:02 +02:00
|
|
|
/* Copy inode data into an audit_names. */
|
2008-11-11 11:48:14 +01:00
|
|
|
static void audit_copy_inode(struct audit_names *name, const struct dentry *dentry,
|
|
|
|
const struct inode *inode)
|
2005-11-03 18:15:16 +01:00
|
|
|
{
|
2006-07-13 19:16:02 +02:00
|
|
|
name->ino = inode->i_ino;
|
|
|
|
name->dev = inode->i_sb->s_dev;
|
|
|
|
name->mode = inode->i_mode;
|
|
|
|
name->uid = inode->i_uid;
|
|
|
|
name->gid = inode->i_gid;
|
|
|
|
name->rdev = inode->i_rdev;
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_inode_getsecid(inode, &name->osid);
|
2008-11-11 11:48:14 +01:00
|
|
|
audit_copy_fcaps(name, dentry);
|
2005-11-03 18:15:16 +01:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_inode - store the inode and device from a lookup
|
|
|
|
* @name: name being audited
|
2007-10-22 05:59:53 +02:00
|
|
|
* @dentry: dentry being audited
|
2005-09-13 21:47:11 +02:00
|
|
|
*
|
|
|
|
* Called from fs/namei.c:path_lookup().
|
|
|
|
*/
|
2007-06-07 18:19:32 +02:00
|
|
|
void __audit_inode(const char *name, const struct dentry *dentry)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
const struct inode *inode = dentry->d_inode;
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!context->in_syscall)
|
|
|
|
return;
|
2012-01-03 20:23:05 +01:00
|
|
|
|
|
|
|
list_for_each_entry_reverse(n, &context->names_list, list) {
|
|
|
|
if (n->name && (n->name == name))
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2012-01-03 20:23:05 +01:00
|
|
|
|
|
|
|
/* unable to find the name from a previous getname() */
|
|
|
|
n = audit_alloc_name(context);
|
|
|
|
if (!n)
|
|
|
|
return;
|
|
|
|
out:
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
handle_path(dentry);
|
2012-01-03 20:23:05 +01:00
|
|
|
audit_copy_inode(n, dentry, inode);
|
2005-11-03 17:00:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* audit_inode_child - collect inode info for created/removed objects
|
2007-10-22 05:59:53 +02:00
|
|
|
* @dentry: dentry being audited
|
2006-07-13 19:16:39 +02:00
|
|
|
* @parent: inode of dentry parent
|
2005-11-03 17:00:25 +01:00
|
|
|
*
|
|
|
|
* For syscalls that create or remove filesystem objects, audit_inode
|
|
|
|
* can only collect information for the filesystem object's parent.
|
|
|
|
* This call updates the audit context with the child's information.
|
|
|
|
* Syscalls that create a new filesystem object must be hooked after
|
|
|
|
* the object is created. Syscalls that remove a filesystem object
|
|
|
|
* must be hooked prior, in order to capture the target inode during
|
|
|
|
* unsuccessful attempts.
|
|
|
|
*/
|
2009-12-25 11:07:33 +01:00
|
|
|
void __audit_inode_child(const struct dentry *dentry,
|
2006-07-13 19:16:39 +02:00
|
|
|
const struct inode *parent)
|
2005-11-03 17:00:25 +01:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2007-02-13 20:15:22 +01:00
|
|
|
const char *found_parent = NULL, *found_child = NULL;
|
2007-06-07 18:19:32 +02:00
|
|
|
const struct inode *inode = dentry->d_inode;
|
2009-12-25 11:07:33 +01:00
|
|
|
const char *dname = dentry->d_name.name;
|
2012-01-03 20:23:05 +01:00
|
|
|
struct audit_names *n;
|
2006-06-09 05:19:31 +02:00
|
|
|
int dirlen = 0;
|
2005-11-03 17:00:25 +01:00
|
|
|
|
|
|
|
if (!context->in_syscall)
|
|
|
|
return;
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 14:04:18 +02:00
|
|
|
if (inode)
|
|
|
|
handle_one(inode);
|
2005-11-03 17:00:25 +01:00
|
|
|
|
2007-02-13 20:15:22 +01:00
|
|
|
/* parent is more likely, look for it first */
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &context->names_list, list) {
|
2007-02-13 20:15:22 +01:00
|
|
|
if (!n->name)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (n->ino == parent->i_ino &&
|
|
|
|
!audit_compare_dname_path(dname, n->name, &dirlen)) {
|
|
|
|
n->name_len = dirlen; /* update parent data in place */
|
|
|
|
found_parent = n->name;
|
|
|
|
goto add_names;
|
[PATCH] audit: path-based rules
In this implementation, audit registers inotify watches on the parent
directories of paths specified in audit rules. When audit's inotify
event handler is called, it updates any affected rules based on the
filesystem event. If the parent directory is renamed, removed, or its
filesystem is unmounted, audit removes all rules referencing that
inotify watch.
To keep things simple, this implementation limits location-based
auditing to the directory entries in an existing directory. Given
a path-based rule for /foo/bar/passwd, the following table applies:
passwd modified -- audit event logged
passwd replaced -- audit event logged, rules list updated
bar renamed -- rule removed
foo renamed -- untracked, meaning that the rule now applies to
the new location
Audit users typically want to have many rules referencing filesystem
objects, which can significantly impact filtering performance. This
patch also adds an inode-number-based rule hash to mitigate this
situation.
The patch is relative to the audit git tree:
http://kernel.org/git/?p=linux/kernel/git/viro/audit-current.git;a=summary
and uses the inotify kernel API:
http://lkml.org/lkml/2006/6/1/145
Signed-off-by: Amy Griffis <amy.griffis@hp.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2006-04-07 22:55:56 +02:00
|
|
|
}
|
2007-02-13 20:15:22 +01:00
|
|
|
}
|
2005-11-03 17:00:25 +01:00
|
|
|
|
2007-02-13 20:15:22 +01:00
|
|
|
/* no matching parent, look for matching child */
|
2012-01-03 20:23:05 +01:00
|
|
|
list_for_each_entry(n, &context->names_list, list) {
|
2007-02-13 20:15:22 +01:00
|
|
|
if (!n->name)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* strcmp() is the more likely scenario */
|
|
|
|
if (!strcmp(dname, n->name) ||
|
|
|
|
!audit_compare_dname_path(dname, n->name, &dirlen)) {
|
|
|
|
if (inode)
|
2012-10-10 21:25:20 +02:00
|
|
|
audit_copy_inode(n, dentry, inode);
|
2007-02-13 20:15:22 +01:00
|
|
|
else
|
|
|
|
n->ino = (unsigned long)-1;
|
|
|
|
found_child = n->name;
|
|
|
|
goto add_names;
|
|
|
|
}
|
2006-09-28 20:31:32 +02:00
|
|
|
}
|
2007-02-13 20:15:22 +01:00
|
|
|
|
|
|
|
add_names:
|
|
|
|
if (!found_parent) {
|
2012-01-03 20:23:05 +01:00
|
|
|
n = audit_alloc_name(context);
|
|
|
|
if (!n)
|
2006-09-28 20:31:32 +02:00
|
|
|
return;
|
2012-01-03 20:23:05 +01:00
|
|
|
audit_copy_inode(n, NULL, parent);
|
2006-07-13 19:16:39 +02:00
|
|
|
}
|
2007-02-13 20:15:22 +01:00
|
|
|
|
|
|
|
if (!found_child) {
|
2012-01-03 20:23:05 +01:00
|
|
|
n = audit_alloc_name(context);
|
|
|
|
if (!n)
|
2007-02-13 20:15:22 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Re-use the name belonging to the slot for a matching parent
|
|
|
|
* directory. All names for this context are relinquished in
|
|
|
|
* audit_free_names() */
|
|
|
|
if (found_parent) {
|
2012-01-03 20:23:05 +01:00
|
|
|
n->name = found_parent;
|
|
|
|
n->name_len = AUDIT_NAME_FULL;
|
2007-02-13 20:15:22 +01:00
|
|
|
/* don't call __putname() */
|
2012-01-03 20:23:05 +01:00
|
|
|
n->name_put = false;
|
2007-02-13 20:15:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (inode)
|
2012-10-10 21:25:20 +02:00
|
|
|
audit_copy_inode(n, dentry, inode);
|
2007-02-13 20:15:22 +01:00
|
|
|
}
|
2006-07-13 19:16:02 +02:00
|
|
|
}
|
2007-06-08 04:44:34 +02:00
|
|
|
EXPORT_SYMBOL_GPL(__audit_inode_child);
|
2006-07-13 19:16:02 +02:00
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* auditsc_get_stamp - get local copies of audit_context values
|
|
|
|
* @ctx: audit_context for the task
|
|
|
|
* @t: timespec to store time recorded in the audit_context
|
|
|
|
* @serial: serial value that is recorded in the audit_context
|
|
|
|
*
|
|
|
|
* Also sets the context as auditable.
|
|
|
|
*/
|
2008-12-06 07:05:50 +01:00
|
|
|
int auditsc_get_stamp(struct audit_context *ctx,
|
2005-05-21 22:08:09 +02:00
|
|
|
struct timespec *t, unsigned int *serial)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-06 07:05:50 +01:00
|
|
|
if (!ctx->in_syscall)
|
|
|
|
return 0;
|
2005-07-18 20:24:46 +02:00
|
|
|
if (!ctx->serial)
|
|
|
|
ctx->serial = audit_serial();
|
2005-05-21 22:08:09 +02:00
|
|
|
t->tv_sec = ctx->ctime.tv_sec;
|
|
|
|
t->tv_nsec = ctx->ctime.tv_nsec;
|
|
|
|
*serial = ctx->serial;
|
2008-12-15 05:45:27 +01:00
|
|
|
if (!ctx->prio) {
|
|
|
|
ctx->prio = 1;
|
|
|
|
ctx->current_state = AUDIT_RECORD_CONTEXT;
|
|
|
|
}
|
2008-12-06 07:05:50 +01:00
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-01-08 16:06:53 +01:00
|
|
|
/* global counter which is incremented every time something logs in */
|
|
|
|
static atomic_t session_id = ATOMIC_INIT(0);
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
2012-01-03 20:23:08 +01:00
|
|
|
* audit_set_loginuid - set current task's audit_context loginuid
|
2005-09-13 21:47:11 +02:00
|
|
|
* @loginuid: loginuid value
|
|
|
|
*
|
|
|
|
* Returns 0.
|
|
|
|
*
|
|
|
|
* Called (set) from fs/proc/base.c::proc_loginuid_write().
|
|
|
|
*/
|
2012-09-11 07:39:43 +02:00
|
|
|
int audit_set_loginuid(kuid_t loginuid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-01-03 20:23:08 +01:00
|
|
|
struct task_struct *task = current;
|
2006-06-12 13:48:28 +02:00
|
|
|
struct audit_context *context = task->audit_context;
|
2012-01-03 20:23:08 +01:00
|
|
|
unsigned int sessionid;
|
2006-06-12 13:48:28 +02:00
|
|
|
|
2012-01-03 20:23:08 +01:00
|
|
|
#ifdef CONFIG_AUDIT_LOGINUID_IMMUTABLE
|
2012-09-11 07:39:43 +02:00
|
|
|
if (uid_valid(task->loginuid))
|
2012-01-03 20:23:08 +01:00
|
|
|
return -EPERM;
|
|
|
|
#else /* CONFIG_AUDIT_LOGINUID_IMMUTABLE */
|
|
|
|
if (!capable(CAP_AUDIT_CONTROL))
|
|
|
|
return -EPERM;
|
|
|
|
#endif /* CONFIG_AUDIT_LOGINUID_IMMUTABLE */
|
|
|
|
|
|
|
|
sessionid = atomic_inc_return(&session_id);
|
2008-01-10 10:53:18 +01:00
|
|
|
if (context && context->in_syscall) {
|
|
|
|
struct audit_buffer *ab;
|
|
|
|
|
|
|
|
ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
|
|
|
|
if (ab) {
|
|
|
|
audit_log_format(ab, "login pid=%d uid=%u "
|
2008-01-08 16:06:53 +01:00
|
|
|
"old auid=%u new auid=%u"
|
|
|
|
" old ses=%u new ses=%u",
|
2012-02-08 01:53:48 +01:00
|
|
|
task->pid,
|
|
|
|
from_kuid(&init_user_ns, task_uid(task)),
|
2012-09-11 07:39:43 +02:00
|
|
|
from_kuid(&init_user_ns, task->loginuid),
|
|
|
|
from_kuid(&init_user_ns, loginuid),
|
2008-01-08 16:06:53 +01:00
|
|
|
task->sessionid, sessionid);
|
2008-01-10 10:53:18 +01:00
|
|
|
audit_log_end(ab);
|
2005-05-13 19:17:42 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-01-08 16:06:53 +01:00
|
|
|
task->sessionid = sessionid;
|
2008-01-10 10:53:18 +01:00
|
|
|
task->loginuid = loginuid;
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-05-24 23:09:55 +02:00
|
|
|
/**
|
|
|
|
* __audit_mq_open - record audit data for a POSIX MQ open
|
|
|
|
* @oflag: open flag
|
|
|
|
* @mode: mode bits
|
2009-01-05 22:41:13 +01:00
|
|
|
* @attr: queue attributes
|
2006-05-24 23:09:55 +02:00
|
|
|
*
|
|
|
|
*/
|
2011-07-26 11:26:10 +02:00
|
|
|
void __audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
|
2006-05-24 23:09:55 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2008-12-14 10:02:26 +01:00
|
|
|
if (attr)
|
|
|
|
memcpy(&context->mq_open.attr, attr, sizeof(struct mq_attr));
|
|
|
|
else
|
|
|
|
memset(&context->mq_open.attr, 0, sizeof(struct mq_attr));
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-14 10:02:26 +01:00
|
|
|
context->mq_open.oflag = oflag;
|
|
|
|
context->mq_open.mode = mode;
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-14 10:02:26 +01:00
|
|
|
context->type = AUDIT_MQ_OPEN;
|
2006-05-24 23:09:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-12-14 09:46:48 +01:00
|
|
|
* __audit_mq_sendrecv - record audit data for a POSIX MQ timed send/receive
|
2006-05-24 23:09:55 +02:00
|
|
|
* @mqdes: MQ descriptor
|
|
|
|
* @msg_len: Message length
|
|
|
|
* @msg_prio: Message priority
|
2008-12-14 09:46:48 +01:00
|
|
|
* @abs_timeout: Message timeout in absolute time
|
2006-05-24 23:09:55 +02:00
|
|
|
*
|
|
|
|
*/
|
2008-12-14 09:46:48 +01:00
|
|
|
void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
|
|
|
|
const struct timespec *abs_timeout)
|
2006-05-24 23:09:55 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2008-12-14 09:46:48 +01:00
|
|
|
struct timespec *p = &context->mq_sendrecv.abs_timeout;
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-14 09:46:48 +01:00
|
|
|
if (abs_timeout)
|
|
|
|
memcpy(p, abs_timeout, sizeof(struct timespec));
|
|
|
|
else
|
|
|
|
memset(p, 0, sizeof(struct timespec));
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-14 09:46:48 +01:00
|
|
|
context->mq_sendrecv.mqdes = mqdes;
|
|
|
|
context->mq_sendrecv.msg_len = msg_len;
|
|
|
|
context->mq_sendrecv.msg_prio = msg_prio;
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-14 09:46:48 +01:00
|
|
|
context->type = AUDIT_MQ_SENDRECV;
|
2006-05-24 23:09:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __audit_mq_notify - record audit data for a POSIX MQ notify
|
|
|
|
* @mqdes: MQ descriptor
|
2009-01-05 22:41:13 +01:00
|
|
|
* @notification: Notification event
|
2006-05-24 23:09:55 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-12-10 13:16:12 +01:00
|
|
|
void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
|
2006-05-24 23:09:55 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2008-12-10 13:16:12 +01:00
|
|
|
if (notification)
|
|
|
|
context->mq_notify.sigev_signo = notification->sigev_signo;
|
|
|
|
else
|
|
|
|
context->mq_notify.sigev_signo = 0;
|
2006-05-24 23:09:55 +02:00
|
|
|
|
2008-12-10 13:16:12 +01:00
|
|
|
context->mq_notify.mqdes = mqdes;
|
|
|
|
context->type = AUDIT_MQ_NOTIFY;
|
2006-05-24 23:09:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __audit_mq_getsetattr - record audit data for a POSIX MQ get/set attribute
|
|
|
|
* @mqdes: MQ descriptor
|
|
|
|
* @mqstat: MQ flags
|
|
|
|
*
|
|
|
|
*/
|
2008-12-10 12:58:59 +01:00
|
|
|
void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
|
2006-05-24 23:09:55 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2008-12-10 12:58:59 +01:00
|
|
|
context->mq_getsetattr.mqdes = mqdes;
|
|
|
|
context->mq_getsetattr.mqstat = *mqstat;
|
|
|
|
context->type = AUDIT_MQ_GETSETATTR;
|
2006-05-24 23:09:55 +02:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
2006-04-02 23:07:33 +02:00
|
|
|
* audit_ipc_obj - record audit data for ipc object
|
|
|
|
* @ipcp: ipc permissions
|
|
|
|
*
|
|
|
|
*/
|
2008-12-10 09:40:06 +01:00
|
|
|
void __audit_ipc_obj(struct kern_ipc_perm *ipcp)
|
2006-04-02 23:07:33 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2008-12-10 09:40:06 +01:00
|
|
|
context->ipc.uid = ipcp->uid;
|
|
|
|
context->ipc.gid = ipcp->gid;
|
|
|
|
context->ipc.mode = ipcp->mode;
|
2008-12-10 09:47:15 +01:00
|
|
|
context->ipc.has_perm = 0;
|
2008-12-10 09:40:06 +01:00
|
|
|
security_ipc_getsecid(ipcp, &context->ipc.osid);
|
|
|
|
context->type = AUDIT_IPC;
|
2006-04-02 23:07:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* audit_ipc_set_perm - record audit data for new ipc permissions
|
2005-09-13 21:47:11 +02:00
|
|
|
* @qbytes: msgq bytes
|
|
|
|
* @uid: msgq user id
|
|
|
|
* @gid: msgq group id
|
|
|
|
* @mode: msgq mode (permissions)
|
|
|
|
*
|
2008-12-10 09:47:15 +01:00
|
|
|
* Called only after audit_ipc_obj().
|
2005-09-13 21:47:11 +02:00
|
|
|
*/
|
2011-07-27 20:03:22 +02:00
|
|
|
void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2008-12-10 09:47:15 +01:00
|
|
|
context->ipc.qbytes = qbytes;
|
|
|
|
context->ipc.perm_uid = uid;
|
|
|
|
context->ipc.perm_gid = gid;
|
|
|
|
context->ipc.perm_mode = mode;
|
|
|
|
context->ipc.has_perm = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-05-06 13:38:39 +02:00
|
|
|
|
2012-01-03 20:23:07 +01:00
|
|
|
int __audit_bprm(struct linux_binprm *bprm)
|
2006-04-26 20:04:08 +02:00
|
|
|
{
|
|
|
|
struct audit_aux_data_execve *ax;
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2007-07-19 10:48:15 +02:00
|
|
|
ax = kmalloc(sizeof(*ax), GFP_KERNEL);
|
2006-04-26 20:04:08 +02:00
|
|
|
if (!ax)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ax->argc = bprm->argc;
|
|
|
|
ax->envc = bprm->envc;
|
2007-07-19 10:48:15 +02:00
|
|
|
ax->mm = bprm->mm;
|
2006-04-26 20:04:08 +02:00
|
|
|
ax->d.type = AUDIT_EXECVE;
|
|
|
|
ax->d.next = context->aux;
|
|
|
|
context->aux = (void *)ax;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_socketcall - record audit data for sys_socketcall
|
|
|
|
* @nargs: number of args
|
|
|
|
* @args: args array
|
|
|
|
*
|
|
|
|
*/
|
2012-01-03 20:23:07 +01:00
|
|
|
void __audit_socketcall(int nargs, unsigned long *args)
|
2005-05-17 13:08:48 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2008-12-10 09:16:51 +01:00
|
|
|
context->type = AUDIT_SOCKETCALL;
|
|
|
|
context->socketcall.nargs = nargs;
|
|
|
|
memcpy(context->socketcall.args, args, nargs * sizeof(unsigned long));
|
2005-05-17 13:08:48 +02:00
|
|
|
}
|
|
|
|
|
2007-02-07 07:48:00 +01:00
|
|
|
/**
|
|
|
|
* __audit_fd_pair - record audit data for pipe and socketpair
|
|
|
|
* @fd1: the first file descriptor
|
|
|
|
* @fd2: the second file descriptor
|
|
|
|
*
|
|
|
|
*/
|
2008-12-14 10:57:47 +01:00
|
|
|
void __audit_fd_pair(int fd1, int fd2)
|
2007-02-07 07:48:00 +01:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2008-12-14 10:57:47 +01:00
|
|
|
context->fds[0] = fd1;
|
|
|
|
context->fds[1] = fd2;
|
2007-02-07 07:48:00 +01:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_sockaddr - record audit data for sys_bind, sys_connect, sys_sendto
|
|
|
|
* @len: data length in user space
|
|
|
|
* @a: data address in kernel space
|
|
|
|
*
|
|
|
|
* Returns 0 for success or NULL context or < 0 on error.
|
|
|
|
*/
|
2012-01-03 20:23:07 +01:00
|
|
|
int __audit_sockaddr(int len, void *a)
|
2005-05-17 13:08:48 +02:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
2008-12-10 01:50:34 +01:00
|
|
|
if (!context->sockaddr) {
|
|
|
|
void *p = kmalloc(sizeof(struct sockaddr_storage), GFP_KERNEL);
|
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
context->sockaddr = p;
|
|
|
|
}
|
2005-05-17 13:08:48 +02:00
|
|
|
|
2008-12-10 01:50:34 +01:00
|
|
|
context->sockaddr_len = len;
|
|
|
|
memcpy(context->sockaddr, a, len);
|
2005-05-17 13:08:48 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-20 18:58:35 +01:00
|
|
|
void __audit_ptrace(struct task_struct *t)
|
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
|
|
|
|
context->target_pid = t->pid;
|
2008-01-07 19:40:17 +01:00
|
|
|
context->target_auid = audit_get_loginuid(t);
|
2008-11-14 00:39:19 +01:00
|
|
|
context->target_uid = task_uid(t);
|
2008-01-08 16:06:53 +01:00
|
|
|
context->target_sessionid = audit_get_sessionid(t);
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(t, &context->target_sid);
|
2008-01-07 19:40:17 +01:00
|
|
|
memcpy(context->target_comm, t->comm, TASK_COMM_LEN);
|
2007-03-20 18:58:35 +01:00
|
|
|
}
|
|
|
|
|
2005-09-13 21:47:11 +02:00
|
|
|
/**
|
|
|
|
* audit_signal_info - record signal info for shutting down audit subsystem
|
|
|
|
* @sig: signal value
|
|
|
|
* @t: task being signaled
|
|
|
|
*
|
|
|
|
* If the audit subsystem is being terminated, record the task (pid)
|
|
|
|
* and uid that is doing that.
|
|
|
|
*/
|
2007-03-30 00:01:04 +02:00
|
|
|
int __audit_signal_info(int sig, struct task_struct *t)
|
2005-05-06 13:38:39 +02:00
|
|
|
{
|
2007-03-30 00:01:04 +02:00
|
|
|
struct audit_aux_data_pids *axp;
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
struct audit_context *ctx = tsk->audit_context;
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t uid = current_uid(), t_uid = task_uid(t);
|
2006-05-25 16:19:47 +02:00
|
|
|
|
2007-08-08 01:01:46 +02:00
|
|
|
if (audit_pid && t->tgid == audit_pid) {
|
2008-07-07 16:49:45 +02:00
|
|
|
if (sig == SIGTERM || sig == SIGHUP || sig == SIGUSR1 || sig == SIGUSR2) {
|
2007-08-08 01:01:46 +02:00
|
|
|
audit_sig_pid = tsk->pid;
|
2012-09-11 07:39:43 +02:00
|
|
|
if (uid_valid(tsk->loginuid))
|
2008-01-10 10:53:18 +01:00
|
|
|
audit_sig_uid = tsk->loginuid;
|
2007-08-08 01:01:46 +02:00
|
|
|
else
|
2008-11-14 00:39:19 +01:00
|
|
|
audit_sig_uid = uid;
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(tsk, &audit_sig_sid);
|
2007-08-08 01:01:46 +02:00
|
|
|
}
|
|
|
|
if (!audit_signals || audit_dummy_context())
|
|
|
|
return 0;
|
2005-05-06 13:38:39 +02:00
|
|
|
}
|
2007-03-30 00:01:04 +02:00
|
|
|
|
|
|
|
/* optimize the common case by putting first signal recipient directly
|
|
|
|
* in audit_context */
|
|
|
|
if (!ctx->target_pid) {
|
|
|
|
ctx->target_pid = t->tgid;
|
2008-01-07 19:40:17 +01:00
|
|
|
ctx->target_auid = audit_get_loginuid(t);
|
2008-11-14 00:39:19 +01:00
|
|
|
ctx->target_uid = t_uid;
|
2008-01-08 16:06:53 +01:00
|
|
|
ctx->target_sessionid = audit_get_sessionid(t);
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(t, &ctx->target_sid);
|
2008-01-07 19:40:17 +01:00
|
|
|
memcpy(ctx->target_comm, t->comm, TASK_COMM_LEN);
|
2007-03-30 00:01:04 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
axp = (void *)ctx->aux_pids;
|
|
|
|
if (!axp || axp->pid_count == AUDIT_AUX_PIDS) {
|
|
|
|
axp = kzalloc(sizeof(*axp), GFP_ATOMIC);
|
|
|
|
if (!axp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
axp->d.type = AUDIT_OBJ_PID;
|
|
|
|
axp->d.next = ctx->aux_pids;
|
|
|
|
ctx->aux_pids = (void *)axp;
|
|
|
|
}
|
2007-08-22 23:01:05 +02:00
|
|
|
BUG_ON(axp->pid_count >= AUDIT_AUX_PIDS);
|
2007-03-30 00:01:04 +02:00
|
|
|
|
|
|
|
axp->target_pid[axp->pid_count] = t->tgid;
|
2008-01-07 19:40:17 +01:00
|
|
|
axp->target_auid[axp->pid_count] = audit_get_loginuid(t);
|
2008-11-14 00:39:19 +01:00
|
|
|
axp->target_uid[axp->pid_count] = t_uid;
|
2008-01-08 16:06:53 +01:00
|
|
|
axp->target_sessionid[axp->pid_count] = audit_get_sessionid(t);
|
Audit: use new LSM hooks instead of SELinux exports
Stop using the following exported SELinux interfaces:
selinux_get_inode_sid(inode, sid)
selinux_get_ipc_sid(ipcp, sid)
selinux_get_task_sid(tsk, sid)
selinux_sid_to_string(sid, ctx, len)
kfree(ctx)
and use following generic LSM equivalents respectively:
security_inode_getsecid(inode, secid)
security_ipc_getsecid*(ipcp, secid)
security_task_getsecid(tsk, secid)
security_sid_to_secctx(sid, ctx, len)
security_release_secctx(ctx, len)
Call security_release_secctx only if security_secid_to_secctx
succeeded.
Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Signed-off-by: Ahmed S. Darwish <darwish.07@gmail.com>
Acked-by: James Morris <jmorris@namei.org>
Reviewed-by: Paul Moore <paul.moore@hp.com>
2008-03-01 20:54:38 +01:00
|
|
|
security_task_getsecid(t, &axp->target_sid[axp->pid_count]);
|
2008-01-07 19:40:17 +01:00
|
|
|
memcpy(axp->target_comm[axp->pid_count], t->comm, TASK_COMM_LEN);
|
2007-03-30 00:01:04 +02:00
|
|
|
axp->pid_count++;
|
|
|
|
|
|
|
|
return 0;
|
2005-05-06 13:38:39 +02:00
|
|
|
}
|
2007-04-19 16:28:21 +02:00
|
|
|
|
2008-11-11 11:48:18 +01:00
|
|
|
/**
|
|
|
|
* __audit_log_bprm_fcaps - store information about a loading bprm and relevant fcaps
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
* @bprm: pointer to the bprm being processed
|
|
|
|
* @new: the proposed new credentials
|
|
|
|
* @old: the old credentials
|
2008-11-11 11:48:18 +01:00
|
|
|
*
|
|
|
|
* Simply check if the proc already has the caps given by the file and if not
|
|
|
|
* store the priv escalation info for later auditing at the end of the syscall
|
|
|
|
*
|
|
|
|
* -Eric
|
|
|
|
*/
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
|
|
|
|
const struct cred *new, const struct cred *old)
|
2008-11-11 11:48:18 +01:00
|
|
|
{
|
|
|
|
struct audit_aux_data_bprm_fcaps *ax;
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
struct cpu_vfs_cap_data vcaps;
|
|
|
|
struct dentry *dentry;
|
|
|
|
|
|
|
|
ax = kmalloc(sizeof(*ax), GFP_KERNEL);
|
|
|
|
if (!ax)
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
return -ENOMEM;
|
2008-11-11 11:48:18 +01:00
|
|
|
|
|
|
|
ax->d.type = AUDIT_BPRM_FCAPS;
|
|
|
|
ax->d.next = context->aux;
|
|
|
|
context->aux = (void *)ax;
|
|
|
|
|
|
|
|
dentry = dget(bprm->file->f_dentry);
|
|
|
|
get_vfs_caps_from_disk(dentry, &vcaps);
|
|
|
|
dput(dentry);
|
|
|
|
|
|
|
|
ax->fcap.permitted = vcaps.permitted;
|
|
|
|
ax->fcap.inheritable = vcaps.inheritable;
|
|
|
|
ax->fcap.fE = !!(vcaps.magic_etc & VFS_CAP_FLAGS_EFFECTIVE);
|
|
|
|
ax->fcap_ver = (vcaps.magic_etc & VFS_CAP_REVISION_MASK) >> VFS_CAP_REVISION_SHIFT;
|
|
|
|
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
ax->old_pcap.permitted = old->cap_permitted;
|
|
|
|
ax->old_pcap.inheritable = old->cap_inheritable;
|
|
|
|
ax->old_pcap.effective = old->cap_effective;
|
2008-11-11 11:48:18 +01:00
|
|
|
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
ax->new_pcap.permitted = new->cap_permitted;
|
|
|
|
ax->new_pcap.inheritable = new->cap_inheritable;
|
|
|
|
ax->new_pcap.effective = new->cap_effective;
|
|
|
|
return 0;
|
2008-11-11 11:48:18 +01:00
|
|
|
}
|
|
|
|
|
2008-11-11 11:48:22 +01:00
|
|
|
/**
|
|
|
|
* __audit_log_capset - store information about the arguments to the capset syscall
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
* @pid: target pid of the capset call
|
|
|
|
* @new: the new credentials
|
|
|
|
* @old: the old (current) credentials
|
2008-11-11 11:48:22 +01:00
|
|
|
*
|
|
|
|
* Record the aguments userspace sent to sys_capset for later printing by the
|
|
|
|
* audit system if applicable
|
|
|
|
*/
|
2009-01-04 20:52:57 +01:00
|
|
|
void __audit_log_capset(pid_t pid,
|
CRED: Inaugurate COW credentials
Inaugurate copy-on-write credentials management. This uses RCU to manage the
credentials pointer in the task_struct with respect to accesses by other tasks.
A process may only modify its own credentials, and so does not need locking to
access or modify its own credentials.
A mutex (cred_replace_mutex) is added to the task_struct to control the effect
of PTRACE_ATTACHED on credential calculations, particularly with respect to
execve().
With this patch, the contents of an active credentials struct may not be
changed directly; rather a new set of credentials must be prepared, modified
and committed using something like the following sequence of events:
struct cred *new = prepare_creds();
int ret = blah(new);
if (ret < 0) {
abort_creds(new);
return ret;
}
return commit_creds(new);
There are some exceptions to this rule: the keyrings pointed to by the active
credentials may be instantiated - keyrings violate the COW rule as managing
COW keyrings is tricky, given that it is possible for a task to directly alter
the keys in a keyring in use by another task.
To help enforce this, various pointers to sets of credentials, such as those in
the task_struct, are declared const. The purpose of this is compile-time
discouragement of altering credentials through those pointers. Once a set of
credentials has been made public through one of these pointers, it may not be
modified, except under special circumstances:
(1) Its reference count may incremented and decremented.
(2) The keyrings to which it points may be modified, but not replaced.
The only safe way to modify anything else is to create a replacement and commit
using the functions described in Documentation/credentials.txt (which will be
added by a later patch).
This patch and the preceding patches have been tested with the LTP SELinux
testsuite.
This patch makes several logical sets of alteration:
(1) execve().
This now prepares and commits credentials in various places in the
security code rather than altering the current creds directly.
(2) Temporary credential overrides.
do_coredump() and sys_faccessat() now prepare their own credentials and
temporarily override the ones currently on the acting thread, whilst
preventing interference from other threads by holding cred_replace_mutex
on the thread being dumped.
This will be replaced in a future patch by something that hands down the
credentials directly to the functions being called, rather than altering
the task's objective credentials.
(3) LSM interface.
A number of functions have been changed, added or removed:
(*) security_capset_check(), ->capset_check()
(*) security_capset_set(), ->capset_set()
Removed in favour of security_capset().
(*) security_capset(), ->capset()
New. This is passed a pointer to the new creds, a pointer to the old
creds and the proposed capability sets. It should fill in the new
creds or return an error. All pointers, barring the pointer to the
new creds, are now const.
(*) security_bprm_apply_creds(), ->bprm_apply_creds()
Changed; now returns a value, which will cause the process to be
killed if it's an error.
(*) security_task_alloc(), ->task_alloc_security()
Removed in favour of security_prepare_creds().
(*) security_cred_free(), ->cred_free()
New. Free security data attached to cred->security.
(*) security_prepare_creds(), ->cred_prepare()
New. Duplicate any security data attached to cred->security.
(*) security_commit_creds(), ->cred_commit()
New. Apply any security effects for the upcoming installation of new
security by commit_creds().
(*) security_task_post_setuid(), ->task_post_setuid()
Removed in favour of security_task_fix_setuid().
(*) security_task_fix_setuid(), ->task_fix_setuid()
Fix up the proposed new credentials for setuid(). This is used by
cap_set_fix_setuid() to implicitly adjust capabilities in line with
setuid() changes. Changes are made to the new credentials, rather
than the task itself as in security_task_post_setuid().
(*) security_task_reparent_to_init(), ->task_reparent_to_init()
Removed. Instead the task being reparented to init is referred
directly to init's credentials.
NOTE! This results in the loss of some state: SELinux's osid no
longer records the sid of the thread that forked it.
(*) security_key_alloc(), ->key_alloc()
(*) security_key_permission(), ->key_permission()
Changed. These now take cred pointers rather than task pointers to
refer to the security context.
(4) sys_capset().
This has been simplified and uses less locking. The LSM functions it
calls have been merged.
(5) reparent_to_kthreadd().
This gives the current thread the same credentials as init by simply using
commit_thread() to point that way.
(6) __sigqueue_alloc() and switch_uid()
__sigqueue_alloc() can't stop the target task from changing its creds
beneath it, so this function gets a reference to the currently applicable
user_struct which it then passes into the sigqueue struct it returns if
successful.
switch_uid() is now called from commit_creds(), and possibly should be
folded into that. commit_creds() should take care of protecting
__sigqueue_alloc().
(7) [sg]et[ug]id() and co and [sg]et_current_groups.
The set functions now all use prepare_creds(), commit_creds() and
abort_creds() to build and check a new set of credentials before applying
it.
security_task_set[ug]id() is called inside the prepared section. This
guarantees that nothing else will affect the creds until we've finished.
The calling of set_dumpable() has been moved into commit_creds().
Much of the functionality of set_user() has been moved into
commit_creds().
The get functions all simply access the data directly.
(8) security_task_prctl() and cap_task_prctl().
security_task_prctl() has been modified to return -ENOSYS if it doesn't
want to handle a function, or otherwise return the return value directly
rather than through an argument.
Additionally, cap_task_prctl() now prepares a new set of credentials, even
if it doesn't end up using it.
(9) Keyrings.
A number of changes have been made to the keyrings code:
(a) switch_uid_keyring(), copy_keys(), exit_keys() and suid_keys() have
all been dropped and built in to the credentials functions directly.
They may want separating out again later.
(b) key_alloc() and search_process_keyrings() now take a cred pointer
rather than a task pointer to specify the security context.
(c) copy_creds() gives a new thread within the same thread group a new
thread keyring if its parent had one, otherwise it discards the thread
keyring.
(d) The authorisation key now points directly to the credentials to extend
the search into rather pointing to the task that carries them.
(e) Installing thread, process or session keyrings causes a new set of
credentials to be created, even though it's not strictly necessary for
process or session keyrings (they're shared).
(10) Usermode helper.
The usermode helper code now carries a cred struct pointer in its
subprocess_info struct instead of a new session keyring pointer. This set
of credentials is derived from init_cred and installed on the new process
after it has been cloned.
call_usermodehelper_setup() allocates the new credentials and
call_usermodehelper_freeinfo() discards them if they haven't been used. A
special cred function (prepare_usermodeinfo_creds()) is provided
specifically for call_usermodehelper_setup() to call.
call_usermodehelper_setkeys() adjusts the credentials to sport the
supplied keyring as the new session keyring.
(11) SELinux.
SELinux has a number of changes, in addition to those to support the LSM
interface changes mentioned above:
(a) selinux_setprocattr() no longer does its check for whether the
current ptracer can access processes with the new SID inside the lock
that covers getting the ptracer's SID. Whilst this lock ensures that
the check is done with the ptracer pinned, the result is only valid
until the lock is released, so there's no point doing it inside the
lock.
(12) is_single_threaded().
This function has been extracted from selinux_setprocattr() and put into
a file of its own in the lib/ directory as join_session_keyring() now
wants to use it too.
The code in SELinux just checked to see whether a task shared mm_structs
with other tasks (CLONE_VM), but that isn't good enough. We really want
to know if they're part of the same thread group (CLONE_THREAD).
(13) nfsd.
The NFS server daemon now has to use the COW credentials to set the
credentials it is going to use. It really needs to pass the credentials
down to the functions it calls, but it can't do that until other patches
in this series have been applied.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: James Morris <jmorris@namei.org>
Signed-off-by: James Morris <jmorris@namei.org>
2008-11-14 00:39:23 +01:00
|
|
|
const struct cred *new, const struct cred *old)
|
2008-11-11 11:48:22 +01:00
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
2009-01-04 20:52:57 +01:00
|
|
|
context->capset.pid = pid;
|
|
|
|
context->capset.cap.effective = new->cap_effective;
|
|
|
|
context->capset.cap.inheritable = new->cap_effective;
|
|
|
|
context->capset.cap.permitted = new->cap_permitted;
|
|
|
|
context->type = AUDIT_CAPSET;
|
2008-11-11 11:48:22 +01:00
|
|
|
}
|
|
|
|
|
2010-10-30 08:54:44 +02:00
|
|
|
void __audit_mmap_fd(int fd, int flags)
|
|
|
|
{
|
|
|
|
struct audit_context *context = current->audit_context;
|
|
|
|
context->mmap.fd = fd;
|
|
|
|
context->mmap.flags = flags;
|
|
|
|
context->type = AUDIT_MMAP;
|
|
|
|
}
|
|
|
|
|
2012-01-03 20:23:05 +01:00
|
|
|
static void audit_log_abend(struct audit_buffer *ab, char *reason, long signr)
|
|
|
|
{
|
2012-02-08 01:53:48 +01:00
|
|
|
kuid_t auid, uid;
|
|
|
|
kgid_t gid;
|
2012-01-03 20:23:05 +01:00
|
|
|
unsigned int sessionid;
|
|
|
|
|
|
|
|
auid = audit_get_loginuid(current);
|
|
|
|
sessionid = audit_get_sessionid(current);
|
|
|
|
current_uid_gid(&uid, &gid);
|
|
|
|
|
|
|
|
audit_log_format(ab, "auid=%u uid=%u gid=%u ses=%u",
|
2012-02-08 01:53:48 +01:00
|
|
|
from_kuid(&init_user_ns, auid),
|
|
|
|
from_kuid(&init_user_ns, uid),
|
|
|
|
from_kgid(&init_user_ns, gid),
|
|
|
|
sessionid);
|
2012-01-03 20:23:05 +01:00
|
|
|
audit_log_task_context(ab);
|
|
|
|
audit_log_format(ab, " pid=%d comm=", current->pid);
|
|
|
|
audit_log_untrustedstring(ab, current->comm);
|
|
|
|
audit_log_format(ab, " reason=");
|
|
|
|
audit_log_string(ab, reason);
|
|
|
|
audit_log_format(ab, " sig=%ld", signr);
|
|
|
|
}
|
2007-04-19 16:28:21 +02:00
|
|
|
/**
|
|
|
|
* audit_core_dumps - record information about processes that end abnormally
|
2007-07-16 08:41:10 +02:00
|
|
|
* @signr: signal value
|
2007-04-19 16:28:21 +02:00
|
|
|
*
|
|
|
|
* If a process ends with a core dump, something fishy is going on and we
|
|
|
|
* should record the event for investigation.
|
|
|
|
*/
|
|
|
|
void audit_core_dumps(long signr)
|
|
|
|
{
|
|
|
|
struct audit_buffer *ab;
|
|
|
|
|
|
|
|
if (!audit_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (signr == SIGQUIT) /* don't care for those */
|
|
|
|
return;
|
|
|
|
|
|
|
|
ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_ANOM_ABEND);
|
2012-01-03 20:23:05 +01:00
|
|
|
audit_log_abend(ab, "memory violation", signr);
|
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
2007-04-19 16:28:21 +02:00
|
|
|
|
2012-04-12 23:47:58 +02:00
|
|
|
void __audit_seccomp(unsigned long syscall, long signr, int code)
|
2012-01-03 20:23:05 +01:00
|
|
|
{
|
|
|
|
struct audit_buffer *ab;
|
|
|
|
|
|
|
|
ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_ANOM_ABEND);
|
2012-04-12 23:47:58 +02:00
|
|
|
audit_log_abend(ab, "seccomp", signr);
|
2012-01-03 20:23:05 +01:00
|
|
|
audit_log_format(ab, " syscall=%ld", syscall);
|
2012-04-12 23:47:58 +02:00
|
|
|
audit_log_format(ab, " compat=%d", is_compat_task());
|
|
|
|
audit_log_format(ab, " ip=0x%lx", KSTK_EIP(current));
|
|
|
|
audit_log_format(ab, " code=0x%x", code);
|
2007-04-19 16:28:21 +02:00
|
|
|
audit_log_end(ab);
|
|
|
|
}
|
2009-06-24 06:02:38 +02:00
|
|
|
|
|
|
|
struct list_head *audit_killed_trees(void)
|
|
|
|
{
|
|
|
|
struct audit_context *ctx = current->audit_context;
|
|
|
|
if (likely(!ctx || !ctx->in_syscall))
|
|
|
|
return NULL;
|
|
|
|
return &ctx->killed_trees;
|
|
|
|
}
|