1 /* auditfilter.c -- filtering of audit events
3 * Copyright 2003-2004 Red Hat, Inc.
4 * Copyright 2005 Hewlett-Packard Development Company, L.P.
5 * Copyright 2005 IBM Corporation
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/kernel.h>
23 #include <linux/audit.h>
24 #include <linux/kthread.h>
25 #include <linux/netlink.h>
28 /* There are three lists of rules -- one to search at task creation
29 * time, one to search at syscall entry time, and another to search at
30 * syscall exit time. */
31 struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
32 LIST_HEAD_INIT(audit_filter_list[0]),
33 LIST_HEAD_INIT(audit_filter_list[1]),
34 LIST_HEAD_INIT(audit_filter_list[2]),
35 LIST_HEAD_INIT(audit_filter_list[3]),
36 LIST_HEAD_INIT(audit_filter_list[4]),
37 LIST_HEAD_INIT(audit_filter_list[5]),
38 #if AUDIT_NR_FILTERS != 6
39 #error Fix audit_filter_list initialiser
43 static inline void audit_free_rule(struct audit_entry *e)
45 kfree(e->rule.fields);
49 static inline void audit_free_rule_rcu(struct rcu_head *head)
51 struct audit_entry *e = container_of(head, struct audit_entry, rcu);
55 /* Unpack a filter field's string representation from user-space
57 static __attribute__((unused)) char *audit_unpack_string(void **bufp, size_t *remain, size_t len)
61 if (!*bufp || (len == 0) || (len > *remain))
62 return ERR_PTR(-EINVAL);
64 /* Of the currently implemented string fields, PATH_MAX
65 * defines the longest valid length.
68 return ERR_PTR(-ENAMETOOLONG);
70 str = kmalloc(len + 1, GFP_KERNEL);
72 return ERR_PTR(-ENOMEM);
74 memcpy(str, *bufp, len);
82 /* Common user-space to kernel rule translation. */
83 static inline struct audit_entry *audit_to_entry_common(struct audit_rule *rule)
86 struct audit_entry *entry;
87 struct audit_field *fields;
91 listnr = rule->flags & ~AUDIT_FILTER_PREPEND;
95 case AUDIT_FILTER_USER:
96 case AUDIT_FILTER_TYPE:
97 #ifdef CONFIG_AUDITSYSCALL
98 case AUDIT_FILTER_ENTRY:
99 case AUDIT_FILTER_EXIT:
100 case AUDIT_FILTER_TASK:
104 if (rule->action != AUDIT_NEVER && rule->action != AUDIT_POSSIBLE &&
105 rule->action != AUDIT_ALWAYS)
107 if (rule->field_count > AUDIT_MAX_FIELDS)
111 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
112 if (unlikely(!entry))
114 fields = kmalloc(sizeof(*fields) * rule->field_count, GFP_KERNEL);
115 if (unlikely(!fields)) {
120 memset(&entry->rule, 0, sizeof(struct audit_krule));
121 memset(fields, 0, sizeof(struct audit_field));
123 entry->rule.flags = rule->flags & AUDIT_FILTER_PREPEND;
124 entry->rule.listnr = listnr;
125 entry->rule.action = rule->action;
126 entry->rule.field_count = rule->field_count;
127 entry->rule.fields = fields;
129 for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
130 entry->rule.mask[i] = rule->mask[i];
138 /* Translate struct audit_rule to kernel's rule respresentation.
139 * Exists for backward compatibility with userspace. */
140 static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
142 struct audit_entry *entry;
146 entry = audit_to_entry_common(rule);
150 for (i = 0; i < rule->field_count; i++) {
151 struct audit_field *f = &entry->rule.fields[i];
153 if (rule->fields[i] & AUDIT_UNUSED_BITS) {
158 f->op = rule->fields[i] & (AUDIT_NEGATE|AUDIT_OPERATORS);
159 f->type = rule->fields[i] & ~(AUDIT_NEGATE|AUDIT_OPERATORS);
160 f->val = rule->values[i];
162 entry->rule.vers_ops = (f->op & AUDIT_OPERATORS) ? 2 : 1;
163 if (f->op & AUDIT_NEGATE)
164 f->op |= AUDIT_NOT_EQUAL;
165 else if (!(f->op & AUDIT_OPERATORS))
166 f->op |= AUDIT_EQUAL;
167 f->op &= ~AUDIT_NEGATE;
174 audit_free_rule(entry);
178 /* Translate struct audit_rule_data to kernel's rule respresentation. */
179 static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
183 struct audit_entry *entry;
185 /* size_t remain = datasz - sizeof(struct audit_rule_data); */
188 entry = audit_to_entry_common((struct audit_rule *)data);
193 entry->rule.vers_ops = 2;
194 for (i = 0; i < data->field_count; i++) {
195 struct audit_field *f = &entry->rule.fields[i];
198 if (!(data->fieldflags[i] & AUDIT_OPERATORS) ||
199 data->fieldflags[i] & ~AUDIT_OPERATORS)
202 f->op = data->fieldflags[i] & AUDIT_OPERATORS;
203 f->type = data->fields[i];
205 /* call type-specific conversion routines here */
207 f->val = data->values[i];
215 audit_free_rule(entry);
219 /* Pack a filter field's string representation into data block. */
220 static inline size_t audit_pack_string(void **bufp, char *str)
222 size_t len = strlen(str);
224 memcpy(*bufp, str, len);
230 /* Translate kernel rule respresentation to struct audit_rule.
231 * Exists for backward compatibility with userspace. */
232 static struct audit_rule *audit_krule_to_rule(struct audit_krule *krule)
234 struct audit_rule *rule;
237 rule = kmalloc(sizeof(*rule), GFP_KERNEL);
239 return ERR_PTR(-ENOMEM);
240 memset(rule, 0, sizeof(*rule));
242 rule->flags = krule->flags | krule->listnr;
243 rule->action = krule->action;
244 rule->field_count = krule->field_count;
245 for (i = 0; i < rule->field_count; i++) {
246 rule->values[i] = krule->fields[i].val;
247 rule->fields[i] = krule->fields[i].type;
249 if (krule->vers_ops == 1) {
250 if (krule->fields[i].op & AUDIT_NOT_EQUAL)
251 rule->fields[i] |= AUDIT_NEGATE;
253 rule->fields[i] |= krule->fields[i].op;
256 for (i = 0; i < AUDIT_BITMASK_SIZE; i++) rule->mask[i] = krule->mask[i];
261 /* Translate kernel rule respresentation to struct audit_rule_data. */
262 static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
264 struct audit_rule_data *data;
268 data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
270 return ERR_PTR(-ENOMEM);
271 memset(data, 0, sizeof(*data));
273 data->flags = krule->flags | krule->listnr;
274 data->action = krule->action;
275 data->field_count = krule->field_count;
277 for (i = 0; i < data->field_count; i++) {
278 struct audit_field *f = &krule->fields[i];
280 data->fields[i] = f->type;
281 data->fieldflags[i] = f->op;
283 /* call type-specific conversion routines here */
285 data->values[i] = f->val;
288 for (i = 0; i < AUDIT_BITMASK_SIZE; i++) data->mask[i] = krule->mask[i];
293 /* Compare two rules in kernel format. Considered success if rules
295 static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
299 if (a->flags != b->flags ||
300 a->listnr != b->listnr ||
301 a->action != b->action ||
302 a->field_count != b->field_count)
305 for (i = 0; i < a->field_count; i++) {
306 if (a->fields[i].type != b->fields[i].type ||
307 a->fields[i].op != b->fields[i].op)
310 switch(a->fields[i].type) {
311 /* call type-specific comparison routines here */
313 if (a->fields[i].val != b->fields[i].val)
318 for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
319 if (a->mask[i] != b->mask[i])
325 /* Add rule to given filterlist if not a duplicate. Protected by
326 * audit_netlink_sem. */
327 static inline int audit_add_rule(struct audit_entry *entry,
328 struct list_head *list)
330 struct audit_entry *e;
332 /* Do not use the _rcu iterator here, since this is the only
333 * addition routine. */
334 list_for_each_entry(e, list, list) {
335 if (!audit_compare_rule(&entry->rule, &e->rule))
339 if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
340 list_add_rcu(&entry->list, list);
342 list_add_tail_rcu(&entry->list, list);
348 /* Remove an existing rule from filterlist. Protected by
349 * audit_netlink_sem. */
350 static inline int audit_del_rule(struct audit_entry *entry,
351 struct list_head *list)
353 struct audit_entry *e;
355 /* Do not use the _rcu iterator here, since this is the only
356 * deletion routine. */
357 list_for_each_entry(e, list, list) {
358 if (!audit_compare_rule(&entry->rule, &e->rule)) {
359 list_del_rcu(&e->list);
360 call_rcu(&e->rcu, audit_free_rule_rcu);
364 return -ENOENT; /* No matching rule */
367 /* List rules using struct audit_rule. Exists for backward
368 * compatibility with userspace. */
369 static int audit_list(void *_dest)
373 struct audit_entry *entry;
380 down(&audit_netlink_sem);
382 /* The *_rcu iterators not needed here because we are
383 always called with audit_netlink_sem held. */
384 for (i=0; i<AUDIT_NR_FILTERS; i++) {
385 list_for_each_entry(entry, &audit_filter_list[i], list) {
386 struct audit_rule *rule;
388 rule = audit_krule_to_rule(&entry->rule);
391 audit_send_reply(pid, seq, AUDIT_LIST, 0, 1,
392 rule, sizeof(*rule));
396 audit_send_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
398 up(&audit_netlink_sem);
402 /* List rules using struct audit_rule_data. */
403 static int audit_list_rules(void *_dest)
407 struct audit_entry *e;
414 down(&audit_netlink_sem);
416 /* The *_rcu iterators not needed here because we are
417 always called with audit_netlink_sem held. */
418 for (i=0; i<AUDIT_NR_FILTERS; i++) {
419 list_for_each_entry(e, &audit_filter_list[i], list) {
420 struct audit_rule_data *data;
422 data = audit_krule_to_data(&e->rule);
425 audit_send_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
426 data, sizeof(*data));
430 audit_send_reply(pid, seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
432 up(&audit_netlink_sem);
437 * audit_receive_filter - apply all rules to the specified message type
438 * @type: audit message type
439 * @pid: target pid for netlink audit messages
440 * @uid: target uid for netlink audit messages
441 * @seq: netlink audit message sequence (serial) number
442 * @data: payload data
443 * @datasz: size of payload data
444 * @loginuid: loginuid of sender
446 int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
447 size_t datasz, uid_t loginuid)
449 struct task_struct *tsk;
452 struct audit_entry *entry;
456 case AUDIT_LIST_RULES:
457 /* We can't just spew out the rules here because we might fill
458 * the available socket buffer space and deadlock waiting for
459 * auditctl to read from it... which isn't ever going to
460 * happen if we're actually running in the context of auditctl
461 * trying to _send_ the stuff */
463 dest = kmalloc(2 * sizeof(int), GFP_KERNEL);
469 if (type == AUDIT_LIST)
470 tsk = kthread_run(audit_list, dest, "audit_list");
472 tsk = kthread_run(audit_list_rules, dest,
481 if (type == AUDIT_ADD)
482 entry = audit_rule_to_entry(data);
484 entry = audit_data_to_entry(data, datasz);
486 return PTR_ERR(entry);
488 err = audit_add_rule(entry,
489 &audit_filter_list[entry->rule.listnr]);
491 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
492 "auid=%u added an audit rule\n", loginuid);
494 audit_free_rule(entry);
498 if (type == AUDIT_DEL)
499 entry = audit_rule_to_entry(data);
501 entry = audit_data_to_entry(data, datasz);
503 return PTR_ERR(entry);
505 err = audit_del_rule(entry,
506 &audit_filter_list[entry->rule.listnr]);
508 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
509 "auid=%u removed an audit rule\n", loginuid);
510 audit_free_rule(entry);
519 int audit_comparator(const u32 left, const u32 op, const u32 right)
523 return (left == right);
524 case AUDIT_NOT_EQUAL:
525 return (left != right);
526 case AUDIT_LESS_THAN:
527 return (left < right);
528 case AUDIT_LESS_THAN_OR_EQUAL:
529 return (left <= right);
530 case AUDIT_GREATER_THAN:
531 return (left > right);
532 case AUDIT_GREATER_THAN_OR_EQUAL:
533 return (left >= right);
541 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
542 struct audit_krule *rule,
543 enum audit_state *state)
547 for (i = 0; i < rule->field_count; i++) {
548 struct audit_field *f = &rule->fields[i];
553 result = audit_comparator(cb->creds.pid, f->op, f->val);
556 result = audit_comparator(cb->creds.uid, f->op, f->val);
559 result = audit_comparator(cb->creds.gid, f->op, f->val);
562 result = audit_comparator(cb->loginuid, f->op, f->val);
569 switch (rule->action) {
570 case AUDIT_NEVER: *state = AUDIT_DISABLED; break;
571 case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT; break;
572 case AUDIT_ALWAYS: *state = AUDIT_RECORD_CONTEXT; break;
577 int audit_filter_user(struct netlink_skb_parms *cb, int type)
579 struct audit_entry *e;
580 enum audit_state state;
584 list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_USER], list) {
585 if (audit_filter_user_rules(cb, &e->rule, &state)) {
586 if (state == AUDIT_DISABLED)
593 return ret; /* Audit by default */
596 int audit_filter_type(int type)
598 struct audit_entry *e;
602 if (list_empty(&audit_filter_list[AUDIT_FILTER_TYPE]))
603 goto unlock_and_return;
605 list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TYPE],
608 for (i = 0; i < e->rule.field_count; i++) {
609 struct audit_field *f = &e->rule.fields[i];
610 if (f->type == AUDIT_MSGTYPE) {
611 result = audit_comparator(type, f->op, f->val);
617 goto unlock_and_return;