Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* auditfilter.c -- filtering of audit events
3 : : *
4 : : * Copyright 2003-2004 Red Hat, Inc.
5 : : * Copyright 2005 Hewlett-Packard Development Company, L.P.
6 : : * Copyright 2005 IBM Corporation
7 : : */
8 : :
9 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 : :
11 : : #include <linux/kernel.h>
12 : : #include <linux/audit.h>
13 : : #include <linux/kthread.h>
14 : : #include <linux/mutex.h>
15 : : #include <linux/fs.h>
16 : : #include <linux/namei.h>
17 : : #include <linux/netlink.h>
18 : : #include <linux/sched.h>
19 : : #include <linux/slab.h>
20 : : #include <linux/security.h>
21 : : #include <net/net_namespace.h>
22 : : #include <net/sock.h>
23 : : #include "audit.h"
24 : :
25 : : /*
26 : : * Locking model:
27 : : *
28 : : * audit_filter_mutex:
29 : : * Synchronizes writes and blocking reads of audit's filterlist
30 : : * data. Rcu is used to traverse the filterlist and access
31 : : * contents of structs audit_entry, audit_watch and opaque
32 : : * LSM rules during filtering. If modified, these structures
33 : : * must be copied and replace their counterparts in the filterlist.
34 : : * An audit_parent struct is not accessed during filtering, so may
35 : : * be written directly provided audit_filter_mutex is held.
36 : : */
37 : :
38 : : /* Audit filter lists, defined in <linux/audit.h> */
39 : : struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
40 : : LIST_HEAD_INIT(audit_filter_list[0]),
41 : : LIST_HEAD_INIT(audit_filter_list[1]),
42 : : LIST_HEAD_INIT(audit_filter_list[2]),
43 : : LIST_HEAD_INIT(audit_filter_list[3]),
44 : : LIST_HEAD_INIT(audit_filter_list[4]),
45 : : LIST_HEAD_INIT(audit_filter_list[5]),
46 : : LIST_HEAD_INIT(audit_filter_list[6]),
47 : : #if AUDIT_NR_FILTERS != 7
48 : : #error Fix audit_filter_list initialiser
49 : : #endif
50 : : };
51 : : static struct list_head audit_rules_list[AUDIT_NR_FILTERS] = {
52 : : LIST_HEAD_INIT(audit_rules_list[0]),
53 : : LIST_HEAD_INIT(audit_rules_list[1]),
54 : : LIST_HEAD_INIT(audit_rules_list[2]),
55 : : LIST_HEAD_INIT(audit_rules_list[3]),
56 : : LIST_HEAD_INIT(audit_rules_list[4]),
57 : : LIST_HEAD_INIT(audit_rules_list[5]),
58 : : LIST_HEAD_INIT(audit_rules_list[6]),
59 : : };
60 : :
61 : : DEFINE_MUTEX(audit_filter_mutex);
62 : :
63 : 0 : static void audit_free_lsm_field(struct audit_field *f)
64 : : {
65 : 0 : switch (f->type) {
66 : : case AUDIT_SUBJ_USER:
67 : : case AUDIT_SUBJ_ROLE:
68 : : case AUDIT_SUBJ_TYPE:
69 : : case AUDIT_SUBJ_SEN:
70 : : case AUDIT_SUBJ_CLR:
71 : : case AUDIT_OBJ_USER:
72 : : case AUDIT_OBJ_ROLE:
73 : : case AUDIT_OBJ_TYPE:
74 : : case AUDIT_OBJ_LEV_LOW:
75 : : case AUDIT_OBJ_LEV_HIGH:
76 : 0 : kfree(f->lsm_str);
77 : 0 : security_audit_rule_free(f->lsm_rule);
78 : : }
79 : 0 : }
80 : :
81 : 0 : static inline void audit_free_rule(struct audit_entry *e)
82 : : {
83 : : int i;
84 : : struct audit_krule *erule = &e->rule;
85 : :
86 : : /* some rules don't have associated watches */
87 : 0 : if (erule->watch)
88 : 0 : audit_put_watch(erule->watch);
89 : 0 : if (erule->fields)
90 : 0 : for (i = 0; i < erule->field_count; i++)
91 : 0 : audit_free_lsm_field(&erule->fields[i]);
92 : 0 : kfree(erule->fields);
93 : 0 : kfree(erule->filterkey);
94 : 0 : kfree(e);
95 : 0 : }
96 : :
97 : 0 : void audit_free_rule_rcu(struct rcu_head *head)
98 : : {
99 : 0 : struct audit_entry *e = container_of(head, struct audit_entry, rcu);
100 : 0 : audit_free_rule(e);
101 : 0 : }
102 : :
103 : : /* Initialize an audit filterlist entry. */
104 : 0 : static inline struct audit_entry *audit_init_entry(u32 field_count)
105 : : {
106 : : struct audit_entry *entry;
107 : : struct audit_field *fields;
108 : :
109 : 0 : entry = kzalloc(sizeof(*entry), GFP_KERNEL);
110 : 0 : if (unlikely(!entry))
111 : : return NULL;
112 : :
113 : : fields = kcalloc(field_count, sizeof(*fields), GFP_KERNEL);
114 : 0 : if (unlikely(!fields)) {
115 : 0 : kfree(entry);
116 : 0 : return NULL;
117 : : }
118 : 0 : entry->rule.fields = fields;
119 : :
120 : 0 : return entry;
121 : : }
122 : :
123 : : /* Unpack a filter field's string representation from user-space
124 : : * buffer. */
125 : 0 : char *audit_unpack_string(void **bufp, size_t *remain, size_t len)
126 : : {
127 : : char *str;
128 : :
129 : 0 : if (!*bufp || (len == 0) || (len > *remain))
130 : : return ERR_PTR(-EINVAL);
131 : :
132 : : /* Of the currently implemented string fields, PATH_MAX
133 : : * defines the longest valid length.
134 : : */
135 : 0 : if (len > PATH_MAX)
136 : : return ERR_PTR(-ENAMETOOLONG);
137 : :
138 : 0 : str = kmalloc(len + 1, GFP_KERNEL);
139 : 0 : if (unlikely(!str))
140 : : return ERR_PTR(-ENOMEM);
141 : :
142 : 0 : memcpy(str, *bufp, len);
143 : 0 : str[len] = 0;
144 : 0 : *bufp += len;
145 : 0 : *remain -= len;
146 : :
147 : 0 : return str;
148 : : }
149 : :
150 : : /* Translate an inode field to kernel representation. */
151 : : static inline int audit_to_inode(struct audit_krule *krule,
152 : : struct audit_field *f)
153 : : {
154 : 0 : if (krule->listnr != AUDIT_FILTER_EXIT ||
155 : 0 : krule->inode_f || krule->watch || krule->tree ||
156 : 0 : (f->op != Audit_equal && f->op != Audit_not_equal))
157 : : return -EINVAL;
158 : :
159 : 0 : krule->inode_f = f;
160 : : return 0;
161 : : }
162 : :
163 : : static __u32 *classes[AUDIT_SYSCALL_CLASSES];
164 : :
165 : 3 : int __init audit_register_class(int class, unsigned *list)
166 : : {
167 : : __u32 *p = kcalloc(AUDIT_BITMASK_SIZE, sizeof(__u32), GFP_KERNEL);
168 : 3 : if (!p)
169 : : return -ENOMEM;
170 : 3 : while (*list != ~0U) {
171 : 3 : unsigned n = *list++;
172 : 3 : if (n >= AUDIT_BITMASK_SIZE * 32 - AUDIT_SYSCALL_CLASSES) {
173 : 0 : kfree(p);
174 : 0 : return -EINVAL;
175 : : }
176 : 3 : p[AUDIT_WORD(n)] |= AUDIT_BIT(n);
177 : : }
178 : 3 : if (class >= AUDIT_SYSCALL_CLASSES || classes[class]) {
179 : 0 : kfree(p);
180 : 0 : return -EINVAL;
181 : : }
182 : 3 : classes[class] = p;
183 : 3 : return 0;
184 : : }
185 : :
186 : 0 : int audit_match_class(int class, unsigned syscall)
187 : : {
188 : 0 : if (unlikely(syscall >= AUDIT_BITMASK_SIZE * 32))
189 : : return 0;
190 : 0 : if (unlikely(class >= AUDIT_SYSCALL_CLASSES || !classes[class]))
191 : : return 0;
192 : 0 : return classes[class][AUDIT_WORD(syscall)] & AUDIT_BIT(syscall);
193 : : }
194 : :
195 : : #ifdef CONFIG_AUDITSYSCALL
196 : : static inline int audit_match_class_bits(int class, u32 *mask)
197 : : {
198 : : int i;
199 : :
200 : 0 : if (classes[class]) {
201 : 0 : for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
202 : 0 : if (mask[i] & classes[class][i])
203 : : return 0;
204 : : }
205 : : return 1;
206 : : }
207 : :
208 : 0 : static int audit_match_signal(struct audit_entry *entry)
209 : : {
210 : 0 : struct audit_field *arch = entry->rule.arch_f;
211 : :
212 : 0 : if (!arch) {
213 : : /* When arch is unspecified, we must check both masks on biarch
214 : : * as syscall number alone is ambiguous. */
215 : 0 : return (audit_match_class_bits(AUDIT_CLASS_SIGNAL,
216 : 0 : entry->rule.mask) &&
217 : : audit_match_class_bits(AUDIT_CLASS_SIGNAL_32,
218 : : entry->rule.mask));
219 : : }
220 : :
221 : 0 : switch(audit_classify_arch(arch->val)) {
222 : : case 0: /* native */
223 : 0 : return (audit_match_class_bits(AUDIT_CLASS_SIGNAL,
224 : 0 : entry->rule.mask));
225 : : case 1: /* 32bit on biarch */
226 : 0 : return (audit_match_class_bits(AUDIT_CLASS_SIGNAL_32,
227 : 0 : entry->rule.mask));
228 : : default:
229 : : return 1;
230 : : }
231 : : }
232 : : #endif
233 : :
234 : : /* Common user-space to kernel rule translation. */
235 : 0 : static inline struct audit_entry *audit_to_entry_common(struct audit_rule_data *rule)
236 : : {
237 : : unsigned listnr;
238 : : struct audit_entry *entry;
239 : : int i, err;
240 : :
241 : : err = -EINVAL;
242 : 0 : listnr = rule->flags & ~AUDIT_FILTER_PREPEND;
243 : 0 : switch(listnr) {
244 : : default:
245 : : goto exit_err;
246 : : #ifdef CONFIG_AUDITSYSCALL
247 : : case AUDIT_FILTER_ENTRY:
248 : 0 : pr_err("AUDIT_FILTER_ENTRY is deprecated\n");
249 : 0 : goto exit_err;
250 : : case AUDIT_FILTER_EXIT:
251 : : case AUDIT_FILTER_TASK:
252 : : #endif
253 : : case AUDIT_FILTER_USER:
254 : : case AUDIT_FILTER_EXCLUDE:
255 : : case AUDIT_FILTER_FS:
256 : : ;
257 : : }
258 : 0 : if (unlikely(rule->action == AUDIT_POSSIBLE)) {
259 : 0 : pr_err("AUDIT_POSSIBLE is deprecated\n");
260 : 0 : goto exit_err;
261 : : }
262 : 0 : if (rule->action != AUDIT_NEVER && rule->action != AUDIT_ALWAYS)
263 : : goto exit_err;
264 : 0 : if (rule->field_count > AUDIT_MAX_FIELDS)
265 : : goto exit_err;
266 : :
267 : : err = -ENOMEM;
268 : 0 : entry = audit_init_entry(rule->field_count);
269 : 0 : if (!entry)
270 : : goto exit_err;
271 : :
272 : 0 : entry->rule.flags = rule->flags & AUDIT_FILTER_PREPEND;
273 : 0 : entry->rule.listnr = listnr;
274 : 0 : entry->rule.action = rule->action;
275 : 0 : entry->rule.field_count = rule->field_count;
276 : :
277 : 0 : for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
278 : 0 : entry->rule.mask[i] = rule->mask[i];
279 : :
280 : 0 : for (i = 0; i < AUDIT_SYSCALL_CLASSES; i++) {
281 : 0 : int bit = AUDIT_BITMASK_SIZE * 32 - i - 1;
282 : 0 : __u32 *p = &entry->rule.mask[AUDIT_WORD(bit)];
283 : : __u32 *class;
284 : :
285 : 0 : if (!(*p & AUDIT_BIT(bit)))
286 : 0 : continue;
287 : 0 : *p &= ~AUDIT_BIT(bit);
288 : 0 : class = classes[i];
289 : 0 : if (class) {
290 : : int j;
291 : 0 : for (j = 0; j < AUDIT_BITMASK_SIZE; j++)
292 : 0 : entry->rule.mask[j] |= class[j];
293 : : }
294 : : }
295 : :
296 : : return entry;
297 : :
298 : : exit_err:
299 : 0 : return ERR_PTR(err);
300 : : }
301 : :
302 : : static u32 audit_ops[] =
303 : : {
304 : : [Audit_equal] = AUDIT_EQUAL,
305 : : [Audit_not_equal] = AUDIT_NOT_EQUAL,
306 : : [Audit_bitmask] = AUDIT_BIT_MASK,
307 : : [Audit_bittest] = AUDIT_BIT_TEST,
308 : : [Audit_lt] = AUDIT_LESS_THAN,
309 : : [Audit_gt] = AUDIT_GREATER_THAN,
310 : : [Audit_le] = AUDIT_LESS_THAN_OR_EQUAL,
311 : : [Audit_ge] = AUDIT_GREATER_THAN_OR_EQUAL,
312 : : };
313 : :
314 : : static u32 audit_to_op(u32 op)
315 : : {
316 : : u32 n;
317 : 0 : for (n = Audit_equal; n < Audit_bad && audit_ops[n] != op; n++)
318 : : ;
319 : 0 : return n;
320 : : }
321 : :
322 : : /* check if an audit field is valid */
323 : 0 : static int audit_field_valid(struct audit_entry *entry, struct audit_field *f)
324 : : {
325 : 0 : switch (f->type) {
326 : : case AUDIT_MSGTYPE:
327 : 0 : if (entry->rule.listnr != AUDIT_FILTER_EXCLUDE &&
328 : : entry->rule.listnr != AUDIT_FILTER_USER)
329 : : return -EINVAL;
330 : : break;
331 : : case AUDIT_FSTYPE:
332 : 0 : if (entry->rule.listnr != AUDIT_FILTER_FS)
333 : : return -EINVAL;
334 : : break;
335 : : }
336 : :
337 : 0 : switch (entry->rule.listnr) {
338 : : case AUDIT_FILTER_FS:
339 : 0 : switch(f->type) {
340 : : case AUDIT_FSTYPE:
341 : : case AUDIT_FILTERKEY:
342 : : break;
343 : : default:
344 : : return -EINVAL;
345 : : }
346 : : }
347 : :
348 : : /* Check for valid field type and op */
349 : 0 : switch (f->type) {
350 : : case AUDIT_ARG0:
351 : : case AUDIT_ARG1:
352 : : case AUDIT_ARG2:
353 : : case AUDIT_ARG3:
354 : : case AUDIT_PERS: /* <uapi/linux/personality.h> */
355 : : case AUDIT_DEVMINOR:
356 : : /* all ops are valid */
357 : : break;
358 : : case AUDIT_UID:
359 : : case AUDIT_EUID:
360 : : case AUDIT_SUID:
361 : : case AUDIT_FSUID:
362 : : case AUDIT_LOGINUID:
363 : : case AUDIT_OBJ_UID:
364 : : case AUDIT_GID:
365 : : case AUDIT_EGID:
366 : : case AUDIT_SGID:
367 : : case AUDIT_FSGID:
368 : : case AUDIT_OBJ_GID:
369 : : case AUDIT_PID:
370 : : case AUDIT_MSGTYPE:
371 : : case AUDIT_PPID:
372 : : case AUDIT_DEVMAJOR:
373 : : case AUDIT_EXIT:
374 : : case AUDIT_SUCCESS:
375 : : case AUDIT_INODE:
376 : : case AUDIT_SESSIONID:
377 : : case AUDIT_SUBJ_SEN:
378 : : case AUDIT_SUBJ_CLR:
379 : : case AUDIT_OBJ_LEV_LOW:
380 : : case AUDIT_OBJ_LEV_HIGH:
381 : : case AUDIT_SADDR_FAM:
382 : : /* bit ops are only useful on syscall args */
383 : 0 : if (f->op == Audit_bitmask || f->op == Audit_bittest)
384 : : return -EINVAL;
385 : : break;
386 : : case AUDIT_SUBJ_USER:
387 : : case AUDIT_SUBJ_ROLE:
388 : : case AUDIT_SUBJ_TYPE:
389 : : case AUDIT_OBJ_USER:
390 : : case AUDIT_OBJ_ROLE:
391 : : case AUDIT_OBJ_TYPE:
392 : : case AUDIT_WATCH:
393 : : case AUDIT_DIR:
394 : : case AUDIT_FILTERKEY:
395 : : case AUDIT_LOGINUID_SET:
396 : : case AUDIT_ARCH:
397 : : case AUDIT_FSTYPE:
398 : : case AUDIT_PERM:
399 : : case AUDIT_FILETYPE:
400 : : case AUDIT_FIELD_COMPARE:
401 : : case AUDIT_EXE:
402 : : /* only equal and not equal valid ops */
403 : 0 : if (f->op != Audit_not_equal && f->op != Audit_equal)
404 : : return -EINVAL;
405 : : break;
406 : : default:
407 : : /* field not recognized */
408 : : return -EINVAL;
409 : : }
410 : :
411 : : /* Check for select valid field values */
412 : 0 : switch (f->type) {
413 : : case AUDIT_LOGINUID_SET:
414 : 0 : if ((f->val != 0) && (f->val != 1))
415 : : return -EINVAL;
416 : : break;
417 : : case AUDIT_PERM:
418 : 0 : if (f->val & ~15)
419 : : return -EINVAL;
420 : : break;
421 : : case AUDIT_FILETYPE:
422 : 0 : if (f->val & ~S_IFMT)
423 : : return -EINVAL;
424 : : break;
425 : : case AUDIT_FIELD_COMPARE:
426 : 0 : if (f->val > AUDIT_MAX_FIELD_COMPARE)
427 : : return -EINVAL;
428 : : break;
429 : : case AUDIT_SADDR_FAM:
430 : 0 : if (f->val >= AF_MAX)
431 : : return -EINVAL;
432 : : break;
433 : : default:
434 : : break;
435 : : }
436 : :
437 : 0 : return 0;
438 : : }
439 : :
440 : : /* Translate struct audit_rule_data to kernel's rule representation. */
441 : 0 : static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
442 : : size_t datasz)
443 : : {
444 : : int err = 0;
445 : : struct audit_entry *entry;
446 : : void *bufp;
447 : 0 : size_t remain = datasz - sizeof(struct audit_rule_data);
448 : : int i;
449 : : char *str;
450 : : struct audit_fsnotify_mark *audit_mark;
451 : :
452 : 0 : entry = audit_to_entry_common(data);
453 : 0 : if (IS_ERR(entry))
454 : : goto exit_nofree;
455 : :
456 : 0 : bufp = data->buf;
457 : 0 : for (i = 0; i < data->field_count; i++) {
458 : 0 : struct audit_field *f = &entry->rule.fields[i];
459 : : u32 f_val;
460 : :
461 : : err = -EINVAL;
462 : :
463 : 0 : f->op = audit_to_op(data->fieldflags[i]);
464 : 0 : if (f->op == Audit_bad)
465 : : goto exit_free;
466 : :
467 : 0 : f->type = data->fields[i];
468 : 0 : f_val = data->values[i];
469 : :
470 : : /* Support legacy tests for a valid loginuid */
471 : 0 : if ((f->type == AUDIT_LOGINUID) && (f_val == AUDIT_UID_UNSET)) {
472 : 0 : f->type = AUDIT_LOGINUID_SET;
473 : : f_val = 0;
474 : 0 : entry->rule.pflags |= AUDIT_LOGINUID_LEGACY;
475 : : }
476 : :
477 : 0 : err = audit_field_valid(entry, f);
478 : 0 : if (err)
479 : : goto exit_free;
480 : :
481 : : err = -EINVAL;
482 : 0 : switch (f->type) {
483 : : case AUDIT_LOGINUID:
484 : : case AUDIT_UID:
485 : : case AUDIT_EUID:
486 : : case AUDIT_SUID:
487 : : case AUDIT_FSUID:
488 : : case AUDIT_OBJ_UID:
489 : 0 : f->uid = make_kuid(current_user_ns(), f_val);
490 : 0 : if (!uid_valid(f->uid))
491 : : goto exit_free;
492 : : break;
493 : : case AUDIT_GID:
494 : : case AUDIT_EGID:
495 : : case AUDIT_SGID:
496 : : case AUDIT_FSGID:
497 : : case AUDIT_OBJ_GID:
498 : 0 : f->gid = make_kgid(current_user_ns(), f_val);
499 : 0 : if (!gid_valid(f->gid))
500 : : goto exit_free;
501 : : break;
502 : : case AUDIT_ARCH:
503 : 0 : f->val = f_val;
504 : 0 : entry->rule.arch_f = f;
505 : 0 : break;
506 : : case AUDIT_SUBJ_USER:
507 : : case AUDIT_SUBJ_ROLE:
508 : : case AUDIT_SUBJ_TYPE:
509 : : case AUDIT_SUBJ_SEN:
510 : : case AUDIT_SUBJ_CLR:
511 : : case AUDIT_OBJ_USER:
512 : : case AUDIT_OBJ_ROLE:
513 : : case AUDIT_OBJ_TYPE:
514 : : case AUDIT_OBJ_LEV_LOW:
515 : : case AUDIT_OBJ_LEV_HIGH:
516 : 0 : str = audit_unpack_string(&bufp, &remain, f_val);
517 : 0 : if (IS_ERR(str)) {
518 : : err = PTR_ERR(str);
519 : 0 : goto exit_free;
520 : : }
521 : 0 : entry->rule.buflen += f_val;
522 : 0 : f->lsm_str = str;
523 : 0 : err = security_audit_rule_init(f->type, f->op, str,
524 : : (void **)&f->lsm_rule);
525 : : /* Keep currently invalid fields around in case they
526 : : * become valid after a policy reload. */
527 : 0 : if (err == -EINVAL) {
528 : 0 : pr_warn("audit rule for LSM \'%s\' is invalid\n",
529 : : str);
530 : : err = 0;
531 : 0 : } else if (err)
532 : : goto exit_free;
533 : : break;
534 : : case AUDIT_WATCH:
535 : 0 : str = audit_unpack_string(&bufp, &remain, f_val);
536 : 0 : if (IS_ERR(str)) {
537 : : err = PTR_ERR(str);
538 : 0 : goto exit_free;
539 : : }
540 : 0 : err = audit_to_watch(&entry->rule, str, f_val, f->op);
541 : 0 : if (err) {
542 : 0 : kfree(str);
543 : 0 : goto exit_free;
544 : : }
545 : 0 : entry->rule.buflen += f_val;
546 : 0 : break;
547 : : case AUDIT_DIR:
548 : 0 : str = audit_unpack_string(&bufp, &remain, f_val);
549 : 0 : if (IS_ERR(str)) {
550 : : err = PTR_ERR(str);
551 : 0 : goto exit_free;
552 : : }
553 : 0 : err = audit_make_tree(&entry->rule, str, f->op);
554 : 0 : kfree(str);
555 : 0 : if (err)
556 : : goto exit_free;
557 : 0 : entry->rule.buflen += f_val;
558 : 0 : break;
559 : : case AUDIT_INODE:
560 : 0 : f->val = f_val;
561 : : err = audit_to_inode(&entry->rule, f);
562 : 0 : if (err)
563 : : goto exit_free;
564 : : break;
565 : : case AUDIT_FILTERKEY:
566 : 0 : if (entry->rule.filterkey || f_val > AUDIT_MAX_KEY_LEN)
567 : : goto exit_free;
568 : 0 : str = audit_unpack_string(&bufp, &remain, f_val);
569 : 0 : if (IS_ERR(str)) {
570 : : err = PTR_ERR(str);
571 : 0 : goto exit_free;
572 : : }
573 : 0 : entry->rule.buflen += f_val;
574 : 0 : entry->rule.filterkey = str;
575 : 0 : break;
576 : : case AUDIT_EXE:
577 : 0 : if (entry->rule.exe || f_val > PATH_MAX)
578 : : goto exit_free;
579 : 0 : str = audit_unpack_string(&bufp, &remain, f_val);
580 : 0 : if (IS_ERR(str)) {
581 : : err = PTR_ERR(str);
582 : 0 : goto exit_free;
583 : : }
584 : 0 : audit_mark = audit_alloc_mark(&entry->rule, str, f_val);
585 : 0 : if (IS_ERR(audit_mark)) {
586 : 0 : kfree(str);
587 : : err = PTR_ERR(audit_mark);
588 : 0 : goto exit_free;
589 : : }
590 : 0 : entry->rule.buflen += f_val;
591 : 0 : entry->rule.exe = audit_mark;
592 : 0 : break;
593 : : default:
594 : 0 : f->val = f_val;
595 : 0 : break;
596 : : }
597 : : }
598 : :
599 : 0 : if (entry->rule.inode_f && entry->rule.inode_f->op == Audit_not_equal)
600 : 0 : entry->rule.inode_f = NULL;
601 : :
602 : : exit_nofree:
603 : 0 : return entry;
604 : :
605 : : exit_free:
606 : 0 : if (entry->rule.tree)
607 : 0 : audit_put_tree(entry->rule.tree); /* that's the temporary one */
608 : 0 : if (entry->rule.exe)
609 : 0 : audit_remove_mark(entry->rule.exe); /* that's the template one */
610 : 0 : audit_free_rule(entry);
611 : 0 : return ERR_PTR(err);
612 : : }
613 : :
614 : : /* Pack a filter field's string representation into data block. */
615 : 0 : static inline size_t audit_pack_string(void **bufp, const char *str)
616 : : {
617 : 0 : size_t len = strlen(str);
618 : :
619 : 0 : memcpy(*bufp, str, len);
620 : 0 : *bufp += len;
621 : :
622 : 0 : return len;
623 : : }
624 : :
625 : : /* Translate kernel rule representation to struct audit_rule_data. */
626 : 0 : static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
627 : : {
628 : : struct audit_rule_data *data;
629 : : void *bufp;
630 : : int i;
631 : :
632 : 0 : data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
633 : 0 : if (unlikely(!data))
634 : : return NULL;
635 : 0 : memset(data, 0, sizeof(*data));
636 : :
637 : 0 : data->flags = krule->flags | krule->listnr;
638 : 0 : data->action = krule->action;
639 : 0 : data->field_count = krule->field_count;
640 : 0 : bufp = data->buf;
641 : 0 : for (i = 0; i < data->field_count; i++) {
642 : 0 : struct audit_field *f = &krule->fields[i];
643 : :
644 : 0 : data->fields[i] = f->type;
645 : 0 : data->fieldflags[i] = audit_ops[f->op];
646 : 0 : switch(f->type) {
647 : : case AUDIT_SUBJ_USER:
648 : : case AUDIT_SUBJ_ROLE:
649 : : case AUDIT_SUBJ_TYPE:
650 : : case AUDIT_SUBJ_SEN:
651 : : case AUDIT_SUBJ_CLR:
652 : : case AUDIT_OBJ_USER:
653 : : case AUDIT_OBJ_ROLE:
654 : : case AUDIT_OBJ_TYPE:
655 : : case AUDIT_OBJ_LEV_LOW:
656 : : case AUDIT_OBJ_LEV_HIGH:
657 : 0 : data->buflen += data->values[i] =
658 : 0 : audit_pack_string(&bufp, f->lsm_str);
659 : 0 : break;
660 : : case AUDIT_WATCH:
661 : 0 : data->buflen += data->values[i] =
662 : 0 : audit_pack_string(&bufp,
663 : 0 : audit_watch_path(krule->watch));
664 : 0 : break;
665 : : case AUDIT_DIR:
666 : 0 : data->buflen += data->values[i] =
667 : 0 : audit_pack_string(&bufp,
668 : : audit_tree_path(krule->tree));
669 : 0 : break;
670 : : case AUDIT_FILTERKEY:
671 : 0 : data->buflen += data->values[i] =
672 : 0 : audit_pack_string(&bufp, krule->filterkey);
673 : 0 : break;
674 : : case AUDIT_EXE:
675 : 0 : data->buflen += data->values[i] =
676 : 0 : audit_pack_string(&bufp, audit_mark_path(krule->exe));
677 : 0 : break;
678 : : case AUDIT_LOGINUID_SET:
679 : 0 : if (krule->pflags & AUDIT_LOGINUID_LEGACY && !f->val) {
680 : 0 : data->fields[i] = AUDIT_LOGINUID;
681 : 0 : data->values[i] = AUDIT_UID_UNSET;
682 : 0 : break;
683 : : }
684 : : /* fall through - if set */
685 : : default:
686 : 0 : data->values[i] = f->val;
687 : : }
688 : : }
689 : 0 : for (i = 0; i < AUDIT_BITMASK_SIZE; i++) data->mask[i] = krule->mask[i];
690 : :
691 : : return data;
692 : : }
693 : :
694 : : /* Compare two rules in kernel format. Considered success if rules
695 : : * don't match. */
696 : 0 : static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
697 : : {
698 : : int i;
699 : :
700 : 0 : if (a->flags != b->flags ||
701 : 0 : a->pflags != b->pflags ||
702 : 0 : a->listnr != b->listnr ||
703 : 0 : a->action != b->action ||
704 : 0 : a->field_count != b->field_count)
705 : : return 1;
706 : :
707 : 0 : for (i = 0; i < a->field_count; i++) {
708 : 0 : if (a->fields[i].type != b->fields[i].type ||
709 : 0 : a->fields[i].op != b->fields[i].op)
710 : : return 1;
711 : :
712 : 0 : switch(a->fields[i].type) {
713 : : case AUDIT_SUBJ_USER:
714 : : case AUDIT_SUBJ_ROLE:
715 : : case AUDIT_SUBJ_TYPE:
716 : : case AUDIT_SUBJ_SEN:
717 : : case AUDIT_SUBJ_CLR:
718 : : case AUDIT_OBJ_USER:
719 : : case AUDIT_OBJ_ROLE:
720 : : case AUDIT_OBJ_TYPE:
721 : : case AUDIT_OBJ_LEV_LOW:
722 : : case AUDIT_OBJ_LEV_HIGH:
723 : 0 : if (strcmp(a->fields[i].lsm_str, b->fields[i].lsm_str))
724 : : return 1;
725 : : break;
726 : : case AUDIT_WATCH:
727 : 0 : if (strcmp(audit_watch_path(a->watch),
728 : 0 : audit_watch_path(b->watch)))
729 : : return 1;
730 : : break;
731 : : case AUDIT_DIR:
732 : 0 : if (strcmp(audit_tree_path(a->tree),
733 : : audit_tree_path(b->tree)))
734 : : return 1;
735 : : break;
736 : : case AUDIT_FILTERKEY:
737 : : /* both filterkeys exist based on above type compare */
738 : 0 : if (strcmp(a->filterkey, b->filterkey))
739 : : return 1;
740 : : break;
741 : : case AUDIT_EXE:
742 : : /* both paths exist based on above type compare */
743 : 0 : if (strcmp(audit_mark_path(a->exe),
744 : 0 : audit_mark_path(b->exe)))
745 : : return 1;
746 : : break;
747 : : case AUDIT_UID:
748 : : case AUDIT_EUID:
749 : : case AUDIT_SUID:
750 : : case AUDIT_FSUID:
751 : : case AUDIT_LOGINUID:
752 : : case AUDIT_OBJ_UID:
753 : 0 : if (!uid_eq(a->fields[i].uid, b->fields[i].uid))
754 : : return 1;
755 : : break;
756 : : case AUDIT_GID:
757 : : case AUDIT_EGID:
758 : : case AUDIT_SGID:
759 : : case AUDIT_FSGID:
760 : : case AUDIT_OBJ_GID:
761 : 0 : if (!gid_eq(a->fields[i].gid, b->fields[i].gid))
762 : : return 1;
763 : : break;
764 : : default:
765 : 0 : if (a->fields[i].val != b->fields[i].val)
766 : : return 1;
767 : : }
768 : : }
769 : :
770 : 0 : for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
771 : 0 : if (a->mask[i] != b->mask[i])
772 : : return 1;
773 : :
774 : : return 0;
775 : : }
776 : :
777 : : /* Duplicate LSM field information. The lsm_rule is opaque, so must be
778 : : * re-initialized. */
779 : 0 : static inline int audit_dupe_lsm_field(struct audit_field *df,
780 : : struct audit_field *sf)
781 : : {
782 : : int ret = 0;
783 : : char *lsm_str;
784 : :
785 : : /* our own copy of lsm_str */
786 : 0 : lsm_str = kstrdup(sf->lsm_str, GFP_KERNEL);
787 : 0 : if (unlikely(!lsm_str))
788 : : return -ENOMEM;
789 : 0 : df->lsm_str = lsm_str;
790 : :
791 : : /* our own (refreshed) copy of lsm_rule */
792 : 0 : ret = security_audit_rule_init(df->type, df->op, df->lsm_str,
793 : : (void **)&df->lsm_rule);
794 : : /* Keep currently invalid fields around in case they
795 : : * become valid after a policy reload. */
796 : 0 : if (ret == -EINVAL) {
797 : 0 : pr_warn("audit rule for LSM \'%s\' is invalid\n",
798 : : df->lsm_str);
799 : : ret = 0;
800 : : }
801 : :
802 : 0 : return ret;
803 : : }
804 : :
805 : : /* Duplicate an audit rule. This will be a deep copy with the exception
806 : : * of the watch - that pointer is carried over. The LSM specific fields
807 : : * will be updated in the copy. The point is to be able to replace the old
808 : : * rule with the new rule in the filterlist, then free the old rule.
809 : : * The rlist element is undefined; list manipulations are handled apart from
810 : : * the initial copy. */
811 : 0 : struct audit_entry *audit_dupe_rule(struct audit_krule *old)
812 : : {
813 : 0 : u32 fcount = old->field_count;
814 : : struct audit_entry *entry;
815 : : struct audit_krule *new;
816 : : char *fk;
817 : : int i, err = 0;
818 : :
819 : 0 : entry = audit_init_entry(fcount);
820 : 0 : if (unlikely(!entry))
821 : : return ERR_PTR(-ENOMEM);
822 : :
823 : 0 : new = &entry->rule;
824 : 0 : new->flags = old->flags;
825 : 0 : new->pflags = old->pflags;
826 : 0 : new->listnr = old->listnr;
827 : 0 : new->action = old->action;
828 : 0 : for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
829 : 0 : new->mask[i] = old->mask[i];
830 : 0 : new->prio = old->prio;
831 : 0 : new->buflen = old->buflen;
832 : 0 : new->inode_f = old->inode_f;
833 : 0 : new->field_count = old->field_count;
834 : :
835 : : /*
836 : : * note that we are OK with not refcounting here; audit_match_tree()
837 : : * never dereferences tree and we can't get false positives there
838 : : * since we'd have to have rule gone from the list *and* removed
839 : : * before the chunks found by lookup had been allocated, i.e. before
840 : : * the beginning of list scan.
841 : : */
842 : 0 : new->tree = old->tree;
843 : 0 : memcpy(new->fields, old->fields, sizeof(struct audit_field) * fcount);
844 : :
845 : : /* deep copy this information, updating the lsm_rule fields, because
846 : : * the originals will all be freed when the old rule is freed. */
847 : 0 : for (i = 0; i < fcount; i++) {
848 : 0 : switch (new->fields[i].type) {
849 : : case AUDIT_SUBJ_USER:
850 : : case AUDIT_SUBJ_ROLE:
851 : : case AUDIT_SUBJ_TYPE:
852 : : case AUDIT_SUBJ_SEN:
853 : : case AUDIT_SUBJ_CLR:
854 : : case AUDIT_OBJ_USER:
855 : : case AUDIT_OBJ_ROLE:
856 : : case AUDIT_OBJ_TYPE:
857 : : case AUDIT_OBJ_LEV_LOW:
858 : : case AUDIT_OBJ_LEV_HIGH:
859 : 0 : err = audit_dupe_lsm_field(&new->fields[i],
860 : 0 : &old->fields[i]);
861 : 0 : break;
862 : : case AUDIT_FILTERKEY:
863 : 0 : fk = kstrdup(old->filterkey, GFP_KERNEL);
864 : 0 : if (unlikely(!fk))
865 : : err = -ENOMEM;
866 : : else
867 : 0 : new->filterkey = fk;
868 : : break;
869 : : case AUDIT_EXE:
870 : 0 : err = audit_dupe_exe(new, old);
871 : 0 : break;
872 : : }
873 : 0 : if (err) {
874 : 0 : if (new->exe)
875 : 0 : audit_remove_mark(new->exe);
876 : 0 : audit_free_rule(entry);
877 : 0 : return ERR_PTR(err);
878 : : }
879 : : }
880 : :
881 : 0 : if (old->watch) {
882 : 0 : audit_get_watch(old->watch);
883 : 0 : new->watch = old->watch;
884 : : }
885 : :
886 : 0 : return entry;
887 : : }
888 : :
889 : : /* Find an existing audit rule.
890 : : * Caller must hold audit_filter_mutex to prevent stale rule data. */
891 : 0 : static struct audit_entry *audit_find_rule(struct audit_entry *entry,
892 : : struct list_head **p)
893 : : {
894 : : struct audit_entry *e, *found = NULL;
895 : : struct list_head *list;
896 : : int h;
897 : :
898 : 0 : if (entry->rule.inode_f) {
899 : 0 : h = audit_hash_ino(entry->rule.inode_f->val);
900 : 0 : *p = list = &audit_inode_hash[h];
901 : 0 : } else if (entry->rule.watch) {
902 : : /* we don't know the inode number, so must walk entire hash */
903 : 0 : for (h = 0; h < AUDIT_INODE_BUCKETS; h++) {
904 : 0 : list = &audit_inode_hash[h];
905 : 0 : list_for_each_entry(e, list, list)
906 : 0 : if (!audit_compare_rule(&entry->rule, &e->rule)) {
907 : 0 : found = e;
908 : 0 : goto out;
909 : : }
910 : : }
911 : : goto out;
912 : : } else {
913 : 0 : *p = list = &audit_filter_list[entry->rule.listnr];
914 : : }
915 : :
916 : 0 : list_for_each_entry(e, list, list)
917 : 0 : if (!audit_compare_rule(&entry->rule, &e->rule)) {
918 : 0 : found = e;
919 : 0 : goto out;
920 : : }
921 : :
922 : : out:
923 : 0 : return found;
924 : : }
925 : :
926 : : static u64 prio_low = ~0ULL/2;
927 : : static u64 prio_high = ~0ULL/2 - 1;
928 : :
929 : : /* Add rule to given filterlist if not a duplicate. */
930 : 0 : static inline int audit_add_rule(struct audit_entry *entry)
931 : : {
932 : : struct audit_entry *e;
933 : 0 : struct audit_watch *watch = entry->rule.watch;
934 : 0 : struct audit_tree *tree = entry->rule.tree;
935 : : struct list_head *list;
936 : : int err = 0;
937 : : #ifdef CONFIG_AUDITSYSCALL
938 : : int dont_count = 0;
939 : :
940 : : /* If any of these, don't count towards total */
941 : 0 : switch(entry->rule.listnr) {
942 : : case AUDIT_FILTER_USER:
943 : : case AUDIT_FILTER_EXCLUDE:
944 : : case AUDIT_FILTER_FS:
945 : : dont_count = 1;
946 : : }
947 : : #endif
948 : :
949 : 0 : mutex_lock(&audit_filter_mutex);
950 : 0 : e = audit_find_rule(entry, &list);
951 : 0 : if (e) {
952 : 0 : mutex_unlock(&audit_filter_mutex);
953 : : err = -EEXIST;
954 : : /* normally audit_add_tree_rule() will free it on failure */
955 : 0 : if (tree)
956 : 0 : audit_put_tree(tree);
957 : : return err;
958 : : }
959 : :
960 : 0 : if (watch) {
961 : : /* audit_filter_mutex is dropped and re-taken during this call */
962 : 0 : err = audit_add_watch(&entry->rule, &list);
963 : 0 : if (err) {
964 : 0 : mutex_unlock(&audit_filter_mutex);
965 : : /*
966 : : * normally audit_add_tree_rule() will free it
967 : : * on failure
968 : : */
969 : 0 : if (tree)
970 : 0 : audit_put_tree(tree);
971 : 0 : return err;
972 : : }
973 : : }
974 : 0 : if (tree) {
975 : 0 : err = audit_add_tree_rule(&entry->rule);
976 : 0 : if (err) {
977 : 0 : mutex_unlock(&audit_filter_mutex);
978 : 0 : return err;
979 : : }
980 : : }
981 : :
982 : 0 : entry->rule.prio = ~0ULL;
983 : 0 : if (entry->rule.listnr == AUDIT_FILTER_EXIT) {
984 : 0 : if (entry->rule.flags & AUDIT_FILTER_PREPEND)
985 : 0 : entry->rule.prio = ++prio_high;
986 : : else
987 : 0 : entry->rule.prio = --prio_low;
988 : : }
989 : :
990 : 0 : if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
991 : 0 : list_add(&entry->rule.list,
992 : : &audit_rules_list[entry->rule.listnr]);
993 : 0 : list_add_rcu(&entry->list, list);
994 : 0 : entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
995 : : } else {
996 : 0 : list_add_tail(&entry->rule.list,
997 : : &audit_rules_list[entry->rule.listnr]);
998 : 0 : list_add_tail_rcu(&entry->list, list);
999 : : }
1000 : : #ifdef CONFIG_AUDITSYSCALL
1001 : 0 : if (!dont_count)
1002 : 0 : audit_n_rules++;
1003 : :
1004 : 0 : if (!audit_match_signal(entry))
1005 : 0 : audit_signals++;
1006 : : #endif
1007 : 0 : mutex_unlock(&audit_filter_mutex);
1008 : :
1009 : 0 : return err;
1010 : : }
1011 : :
1012 : : /* Remove an existing rule from filterlist. */
1013 : 0 : int audit_del_rule(struct audit_entry *entry)
1014 : : {
1015 : : struct audit_entry *e;
1016 : 0 : struct audit_tree *tree = entry->rule.tree;
1017 : : struct list_head *list;
1018 : : int ret = 0;
1019 : : #ifdef CONFIG_AUDITSYSCALL
1020 : : int dont_count = 0;
1021 : :
1022 : : /* If any of these, don't count towards total */
1023 : 0 : switch(entry->rule.listnr) {
1024 : : case AUDIT_FILTER_USER:
1025 : : case AUDIT_FILTER_EXCLUDE:
1026 : : case AUDIT_FILTER_FS:
1027 : : dont_count = 1;
1028 : : }
1029 : : #endif
1030 : :
1031 : 0 : mutex_lock(&audit_filter_mutex);
1032 : 0 : e = audit_find_rule(entry, &list);
1033 : 0 : if (!e) {
1034 : : ret = -ENOENT;
1035 : : goto out;
1036 : : }
1037 : :
1038 : 0 : if (e->rule.watch)
1039 : 0 : audit_remove_watch_rule(&e->rule);
1040 : :
1041 : 0 : if (e->rule.tree)
1042 : 0 : audit_remove_tree_rule(&e->rule);
1043 : :
1044 : 0 : if (e->rule.exe)
1045 : 0 : audit_remove_mark_rule(&e->rule);
1046 : :
1047 : : #ifdef CONFIG_AUDITSYSCALL
1048 : 0 : if (!dont_count)
1049 : 0 : audit_n_rules--;
1050 : :
1051 : 0 : if (!audit_match_signal(entry))
1052 : 0 : audit_signals--;
1053 : : #endif
1054 : :
1055 : : list_del_rcu(&e->list);
1056 : : list_del(&e->rule.list);
1057 : 0 : call_rcu(&e->rcu, audit_free_rule_rcu);
1058 : :
1059 : : out:
1060 : 0 : mutex_unlock(&audit_filter_mutex);
1061 : :
1062 : 0 : if (tree)
1063 : 0 : audit_put_tree(tree); /* that's the temporary one */
1064 : :
1065 : 0 : return ret;
1066 : : }
1067 : :
1068 : : /* List rules using struct audit_rule_data. */
1069 : 0 : static void audit_list_rules(int seq, struct sk_buff_head *q)
1070 : : {
1071 : : struct sk_buff *skb;
1072 : : struct audit_krule *r;
1073 : : int i;
1074 : :
1075 : : /* This is a blocking read, so use audit_filter_mutex instead of rcu
1076 : : * iterator to sync with list writers. */
1077 : 0 : for (i=0; i<AUDIT_NR_FILTERS; i++) {
1078 : 0 : list_for_each_entry(r, &audit_rules_list[i], list) {
1079 : : struct audit_rule_data *data;
1080 : :
1081 : 0 : data = audit_krule_to_data(r);
1082 : 0 : if (unlikely(!data))
1083 : : break;
1084 : 0 : skb = audit_make_reply(seq, AUDIT_LIST_RULES, 0, 1,
1085 : : data,
1086 : 0 : sizeof(*data) + data->buflen);
1087 : 0 : if (skb)
1088 : 0 : skb_queue_tail(q, skb);
1089 : 0 : kfree(data);
1090 : : }
1091 : : }
1092 : 0 : skb = audit_make_reply(seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
1093 : 0 : if (skb)
1094 : 0 : skb_queue_tail(q, skb);
1095 : 0 : }
1096 : :
1097 : : /* Log rule additions and removals */
1098 : 0 : static void audit_log_rule_change(char *action, struct audit_krule *rule, int res)
1099 : : {
1100 : : struct audit_buffer *ab;
1101 : :
1102 : 0 : if (!audit_enabled)
1103 : : return;
1104 : :
1105 : 0 : ab = audit_log_start(audit_context(), GFP_KERNEL, AUDIT_CONFIG_CHANGE);
1106 : 0 : if (!ab)
1107 : : return;
1108 : 0 : audit_log_session_info(ab);
1109 : 0 : audit_log_task_context(ab);
1110 : 0 : audit_log_format(ab, " op=%s", action);
1111 : 0 : audit_log_key(ab, rule->filterkey);
1112 : 0 : audit_log_format(ab, " list=%d res=%d", rule->listnr, res);
1113 : 0 : audit_log_end(ab);
1114 : : }
1115 : :
1116 : : /**
1117 : : * audit_rule_change - apply all rules to the specified message type
1118 : : * @type: audit message type
1119 : : * @seq: netlink audit message sequence (serial) number
1120 : : * @data: payload data
1121 : : * @datasz: size of payload data
1122 : : */
1123 : 0 : int audit_rule_change(int type, int seq, void *data, size_t datasz)
1124 : : {
1125 : : int err = 0;
1126 : : struct audit_entry *entry;
1127 : :
1128 : 0 : switch (type) {
1129 : : case AUDIT_ADD_RULE:
1130 : 0 : entry = audit_data_to_entry(data, datasz);
1131 : 0 : if (IS_ERR(entry))
1132 : 0 : return PTR_ERR(entry);
1133 : 0 : err = audit_add_rule(entry);
1134 : 0 : audit_log_rule_change("add_rule", &entry->rule, !err);
1135 : 0 : break;
1136 : : case AUDIT_DEL_RULE:
1137 : 0 : entry = audit_data_to_entry(data, datasz);
1138 : 0 : if (IS_ERR(entry))
1139 : 0 : return PTR_ERR(entry);
1140 : 0 : err = audit_del_rule(entry);
1141 : 0 : audit_log_rule_change("remove_rule", &entry->rule, !err);
1142 : 0 : break;
1143 : : default:
1144 : 0 : WARN_ON(1);
1145 : 0 : return -EINVAL;
1146 : : }
1147 : :
1148 : 0 : if (err || type == AUDIT_DEL_RULE) {
1149 : 0 : if (entry->rule.exe)
1150 : 0 : audit_remove_mark(entry->rule.exe);
1151 : 0 : audit_free_rule(entry);
1152 : : }
1153 : :
1154 : 0 : return err;
1155 : : }
1156 : :
1157 : : /**
1158 : : * audit_list_rules_send - list the audit rules
1159 : : * @request_skb: skb of request we are replying to (used to target the reply)
1160 : : * @seq: netlink audit message sequence (serial) number
1161 : : */
1162 : 0 : int audit_list_rules_send(struct sk_buff *request_skb, int seq)
1163 : : {
1164 : : struct task_struct *tsk;
1165 : : struct audit_netlink_list *dest;
1166 : :
1167 : : /* We can't just spew out the rules here because we might fill
1168 : : * the available socket buffer space and deadlock waiting for
1169 : : * auditctl to read from it... which isn't ever going to
1170 : : * happen if we're actually running in the context of auditctl
1171 : : * trying to _send_ the stuff */
1172 : :
1173 : : dest = kmalloc(sizeof(*dest), GFP_KERNEL);
1174 : 0 : if (!dest)
1175 : : return -ENOMEM;
1176 : 0 : dest->net = get_net(sock_net(NETLINK_CB(request_skb).sk));
1177 : 0 : dest->portid = NETLINK_CB(request_skb).portid;
1178 : 0 : skb_queue_head_init(&dest->q);
1179 : :
1180 : 0 : mutex_lock(&audit_filter_mutex);
1181 : 0 : audit_list_rules(seq, &dest->q);
1182 : 0 : mutex_unlock(&audit_filter_mutex);
1183 : :
1184 : 0 : tsk = kthread_run(audit_send_list_thread, dest, "audit_send_list");
1185 : 0 : if (IS_ERR(tsk)) {
1186 : 0 : skb_queue_purge(&dest->q);
1187 : 0 : put_net(dest->net);
1188 : 0 : kfree(dest);
1189 : 0 : return PTR_ERR(tsk);
1190 : : }
1191 : :
1192 : : return 0;
1193 : : }
1194 : :
1195 : 0 : int audit_comparator(u32 left, u32 op, u32 right)
1196 : : {
1197 : 0 : switch (op) {
1198 : : case Audit_equal:
1199 : 0 : return (left == right);
1200 : : case Audit_not_equal:
1201 : 0 : return (left != right);
1202 : : case Audit_lt:
1203 : 0 : return (left < right);
1204 : : case Audit_le:
1205 : 0 : return (left <= right);
1206 : : case Audit_gt:
1207 : 0 : return (left > right);
1208 : : case Audit_ge:
1209 : 0 : return (left >= right);
1210 : : case Audit_bitmask:
1211 : 0 : return (left & right);
1212 : : case Audit_bittest:
1213 : 0 : return ((left & right) == right);
1214 : : default:
1215 : : return 0;
1216 : : }
1217 : : }
1218 : :
1219 : 0 : int audit_uid_comparator(kuid_t left, u32 op, kuid_t right)
1220 : : {
1221 : 0 : switch (op) {
1222 : : case Audit_equal:
1223 : 0 : return uid_eq(left, right);
1224 : : case Audit_not_equal:
1225 : 0 : return !uid_eq(left, right);
1226 : : case Audit_lt:
1227 : 0 : return uid_lt(left, right);
1228 : : case Audit_le:
1229 : 0 : return uid_lte(left, right);
1230 : : case Audit_gt:
1231 : 0 : return uid_gt(left, right);
1232 : : case Audit_ge:
1233 : 0 : return uid_gte(left, right);
1234 : : case Audit_bitmask:
1235 : : case Audit_bittest:
1236 : : default:
1237 : : return 0;
1238 : : }
1239 : : }
1240 : :
1241 : 0 : int audit_gid_comparator(kgid_t left, u32 op, kgid_t right)
1242 : : {
1243 : 0 : switch (op) {
1244 : : case Audit_equal:
1245 : 0 : return gid_eq(left, right);
1246 : : case Audit_not_equal:
1247 : 0 : return !gid_eq(left, right);
1248 : : case Audit_lt:
1249 : 0 : return gid_lt(left, right);
1250 : : case Audit_le:
1251 : 0 : return gid_lte(left, right);
1252 : : case Audit_gt:
1253 : 0 : return gid_gt(left, right);
1254 : : case Audit_ge:
1255 : 0 : return gid_gte(left, right);
1256 : : case Audit_bitmask:
1257 : : case Audit_bittest:
1258 : : default:
1259 : : return 0;
1260 : : }
1261 : : }
1262 : :
1263 : : /**
1264 : : * parent_len - find the length of the parent portion of a pathname
1265 : : * @path: pathname of which to determine length
1266 : : */
1267 : 0 : int parent_len(const char *path)
1268 : : {
1269 : : int plen;
1270 : : const char *p;
1271 : :
1272 : 0 : plen = strlen(path);
1273 : :
1274 : 0 : if (plen == 0)
1275 : : return plen;
1276 : :
1277 : : /* disregard trailing slashes */
1278 : 0 : p = path + plen - 1;
1279 : 0 : while ((*p == '/') && (p > path))
1280 : 0 : p--;
1281 : :
1282 : : /* walk backward until we find the next slash or hit beginning */
1283 : 0 : while ((*p != '/') && (p > path))
1284 : 0 : p--;
1285 : :
1286 : : /* did we find a slash? Then increment to include it in path */
1287 : 0 : if (*p == '/')
1288 : 0 : p++;
1289 : :
1290 : 0 : return p - path;
1291 : : }
1292 : :
1293 : : /**
1294 : : * audit_compare_dname_path - compare given dentry name with last component in
1295 : : * given path. Return of 0 indicates a match.
1296 : : * @dname: dentry name that we're comparing
1297 : : * @path: full pathname that we're comparing
1298 : : * @parentlen: length of the parent if known. Passing in AUDIT_NAME_FULL
1299 : : * here indicates that we must compute this value.
1300 : : */
1301 : 0 : int audit_compare_dname_path(const struct qstr *dname, const char *path, int parentlen)
1302 : : {
1303 : : int dlen, pathlen;
1304 : : const char *p;
1305 : :
1306 : 0 : dlen = dname->len;
1307 : 0 : pathlen = strlen(path);
1308 : 0 : if (pathlen < dlen)
1309 : : return 1;
1310 : :
1311 : 0 : parentlen = parentlen == AUDIT_NAME_FULL ? parent_len(path) : parentlen;
1312 : 0 : if (pathlen - parentlen != dlen)
1313 : : return 1;
1314 : :
1315 : 0 : p = path + parentlen;
1316 : :
1317 : 0 : return strncmp(p, dname->name, dlen);
1318 : : }
1319 : :
1320 : 3 : int audit_filter(int msgtype, unsigned int listtype)
1321 : : {
1322 : : struct audit_entry *e;
1323 : : int ret = 1; /* Audit by default */
1324 : :
1325 : : rcu_read_lock();
1326 : 3 : list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) {
1327 : : int i, result = 0;
1328 : :
1329 : 0 : for (i = 0; i < e->rule.field_count; i++) {
1330 : 0 : struct audit_field *f = &e->rule.fields[i];
1331 : : pid_t pid;
1332 : : u32 sid;
1333 : :
1334 : 0 : switch (f->type) {
1335 : : case AUDIT_PID:
1336 : 0 : pid = task_pid_nr(current);
1337 : 0 : result = audit_comparator(pid, f->op, f->val);
1338 : 0 : break;
1339 : : case AUDIT_UID:
1340 : 0 : result = audit_uid_comparator(current_uid(), f->op, f->uid);
1341 : 0 : break;
1342 : : case AUDIT_GID:
1343 : 0 : result = audit_gid_comparator(current_gid(), f->op, f->gid);
1344 : 0 : break;
1345 : : case AUDIT_LOGINUID:
1346 : 0 : result = audit_uid_comparator(audit_get_loginuid(current),
1347 : : f->op, f->uid);
1348 : 0 : break;
1349 : : case AUDIT_LOGINUID_SET:
1350 : 0 : result = audit_comparator(audit_loginuid_set(current),
1351 : : f->op, f->val);
1352 : 0 : break;
1353 : : case AUDIT_MSGTYPE:
1354 : 0 : result = audit_comparator(msgtype, f->op, f->val);
1355 : 0 : break;
1356 : : case AUDIT_SUBJ_USER:
1357 : : case AUDIT_SUBJ_ROLE:
1358 : : case AUDIT_SUBJ_TYPE:
1359 : : case AUDIT_SUBJ_SEN:
1360 : : case AUDIT_SUBJ_CLR:
1361 : 0 : if (f->lsm_rule) {
1362 : 0 : security_task_getsecid(current, &sid);
1363 : 0 : result = security_audit_rule_match(sid,
1364 : : f->type, f->op, f->lsm_rule);
1365 : : }
1366 : : break;
1367 : : case AUDIT_EXE:
1368 : 0 : result = audit_exe_compare(current, e->rule.exe);
1369 : 0 : if (f->op == Audit_not_equal)
1370 : 0 : result = !result;
1371 : : break;
1372 : : default:
1373 : 0 : goto unlock_and_return;
1374 : : }
1375 : 0 : if (result < 0) /* error */
1376 : : goto unlock_and_return;
1377 : 0 : if (!result)
1378 : : break;
1379 : : }
1380 : 0 : if (result > 0) {
1381 : 0 : if (e->rule.action == AUDIT_NEVER || listtype == AUDIT_FILTER_EXCLUDE)
1382 : : ret = 0;
1383 : : break;
1384 : : }
1385 : : }
1386 : : unlock_and_return:
1387 : : rcu_read_unlock();
1388 : 3 : return ret;
1389 : : }
1390 : :
1391 : 0 : static int update_lsm_rule(struct audit_krule *r)
1392 : : {
1393 : : struct audit_entry *entry = container_of(r, struct audit_entry, rule);
1394 : : struct audit_entry *nentry;
1395 : : int err = 0;
1396 : :
1397 : 0 : if (!security_audit_rule_known(r))
1398 : : return 0;
1399 : :
1400 : 0 : nentry = audit_dupe_rule(r);
1401 : 0 : if (entry->rule.exe)
1402 : 0 : audit_remove_mark(entry->rule.exe);
1403 : 0 : if (IS_ERR(nentry)) {
1404 : : /* save the first error encountered for the
1405 : : * return value */
1406 : : err = PTR_ERR(nentry);
1407 : 0 : audit_panic("error updating LSM filters");
1408 : 0 : if (r->watch)
1409 : : list_del(&r->rlist);
1410 : : list_del_rcu(&entry->list);
1411 : : list_del(&r->list);
1412 : : } else {
1413 : 0 : if (r->watch || r->tree)
1414 : 0 : list_replace_init(&r->rlist, &nentry->rule.rlist);
1415 : 0 : list_replace_rcu(&entry->list, &nentry->list);
1416 : 0 : list_replace(&r->list, &nentry->rule.list);
1417 : : }
1418 : 0 : call_rcu(&entry->rcu, audit_free_rule_rcu);
1419 : :
1420 : 0 : return err;
1421 : : }
1422 : :
1423 : : /* This function will re-initialize the lsm_rule field of all applicable rules.
1424 : : * It will traverse the filter lists serarching for rules that contain LSM
1425 : : * specific filter fields. When such a rule is found, it is copied, the
1426 : : * LSM field is re-initialized, and the old rule is replaced with the
1427 : : * updated rule. */
1428 : 0 : int audit_update_lsm_rules(void)
1429 : : {
1430 : : struct audit_krule *r, *n;
1431 : : int i, err = 0;
1432 : :
1433 : : /* audit_filter_mutex synchronizes the writers */
1434 : 0 : mutex_lock(&audit_filter_mutex);
1435 : :
1436 : 0 : for (i = 0; i < AUDIT_NR_FILTERS; i++) {
1437 : 0 : list_for_each_entry_safe(r, n, &audit_rules_list[i], list) {
1438 : 0 : int res = update_lsm_rule(r);
1439 : 0 : if (!err)
1440 : : err = res;
1441 : : }
1442 : : }
1443 : 0 : mutex_unlock(&audit_filter_mutex);
1444 : :
1445 : 0 : return err;
1446 : : }
|
