Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* audit_watch.c -- watching inodes
3 : : *
4 : : * Copyright 2003-2009 Red Hat, Inc.
5 : : * Copyright 2005 Hewlett-Packard Development Company, L.P.
6 : : * Copyright 2005 IBM Corporation
7 : : */
8 : :
9 : : #include <linux/file.h>
10 : : #include <linux/kernel.h>
11 : : #include <linux/audit.h>
12 : : #include <linux/kthread.h>
13 : : #include <linux/mutex.h>
14 : : #include <linux/fs.h>
15 : : #include <linux/fsnotify_backend.h>
16 : : #include <linux/namei.h>
17 : : #include <linux/netlink.h>
18 : : #include <linux/refcount.h>
19 : : #include <linux/sched.h>
20 : : #include <linux/slab.h>
21 : : #include <linux/security.h>
22 : : #include "audit.h"
23 : :
24 : : /*
25 : : * Reference counting:
26 : : *
27 : : * audit_parent: lifetime is from audit_init_parent() to receipt of an FS_IGNORED
28 : : * event. Each audit_watch holds a reference to its associated parent.
29 : : *
30 : : * audit_watch: if added to lists, lifetime is from audit_init_watch() to
31 : : * audit_remove_watch(). Additionally, an audit_watch may exist
32 : : * temporarily to assist in searching existing filter data. Each
33 : : * audit_krule holds a reference to its associated watch.
34 : : */
35 : :
36 : : struct audit_watch {
37 : : refcount_t count; /* reference count */
38 : : dev_t dev; /* associated superblock device */
39 : : char *path; /* insertion path */
40 : : unsigned long ino; /* associated inode number */
41 : : struct audit_parent *parent; /* associated parent */
42 : : struct list_head wlist; /* entry in parent->watches list */
43 : : struct list_head rules; /* anchor for krule->rlist */
44 : : };
45 : :
46 : : struct audit_parent {
47 : : struct list_head watches; /* anchor for audit_watch->wlist */
48 : : struct fsnotify_mark mark; /* fsnotify mark on the inode */
49 : : };
50 : :
51 : : /* fsnotify handle. */
52 : : static struct fsnotify_group *audit_watch_group;
53 : :
54 : : /* fsnotify events we care about. */
55 : : #define AUDIT_FS_WATCH (FS_MOVE | FS_CREATE | FS_DELETE | FS_DELETE_SELF |\
56 : : FS_MOVE_SELF | FS_EVENT_ON_CHILD | FS_UNMOUNT)
57 : :
58 : 0 : static void audit_free_parent(struct audit_parent *parent)
59 : : {
60 [ # # ]: 0 : WARN_ON(!list_empty(&parent->watches));
61 : 0 : kfree(parent);
62 : 0 : }
63 : :
64 : 0 : static void audit_watch_free_mark(struct fsnotify_mark *entry)
65 : : {
66 : : struct audit_parent *parent;
67 : :
68 : 0 : parent = container_of(entry, struct audit_parent, mark);
69 : 0 : audit_free_parent(parent);
70 : 0 : }
71 : :
72 : : static void audit_get_parent(struct audit_parent *parent)
73 : : {
74 [ # # # # ]: 0 : if (likely(parent))
75 : 0 : fsnotify_get_mark(&parent->mark);
76 : : }
77 : :
78 : : static void audit_put_parent(struct audit_parent *parent)
79 : : {
80 [ # # # # : 0 : if (likely(parent))
# # ]
81 : 0 : fsnotify_put_mark(&parent->mark);
82 : : }
83 : :
84 : : /*
85 : : * Find and return the audit_parent on the given inode. If found a reference
86 : : * is taken on this parent.
87 : : */
88 : : static inline struct audit_parent *audit_find_parent(struct inode *inode)
89 : : {
90 : : struct audit_parent *parent = NULL;
91 : : struct fsnotify_mark *entry;
92 : :
93 : 0 : entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_watch_group);
94 [ # # ]: 0 : if (entry)
95 : 0 : parent = container_of(entry, struct audit_parent, mark);
96 : :
97 : : return parent;
98 : : }
99 : :
100 : 0 : void audit_get_watch(struct audit_watch *watch)
101 : : {
102 : 0 : refcount_inc(&watch->count);
103 : 0 : }
104 : :
105 : 0 : void audit_put_watch(struct audit_watch *watch)
106 : : {
107 [ # # ]: 0 : if (refcount_dec_and_test(&watch->count)) {
108 [ # # ]: 0 : WARN_ON(watch->parent);
109 [ # # ]: 0 : WARN_ON(!list_empty(&watch->rules));
110 : 0 : kfree(watch->path);
111 : 0 : kfree(watch);
112 : : }
113 : 0 : }
114 : :
115 : 0 : static void audit_remove_watch(struct audit_watch *watch)
116 : : {
117 : : list_del(&watch->wlist);
118 : 0 : audit_put_parent(watch->parent);
119 : 0 : watch->parent = NULL;
120 : 0 : audit_put_watch(watch); /* match initial get */
121 : 0 : }
122 : :
123 : 0 : char *audit_watch_path(struct audit_watch *watch)
124 : : {
125 : 0 : return watch->path;
126 : : }
127 : :
128 : 0 : int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
129 : : {
130 [ # # ]: 0 : return (watch->ino != AUDIT_INO_UNSET) &&
131 [ # # # # ]: 0 : (watch->ino == ino) &&
132 : 0 : (watch->dev == dev);
133 : : }
134 : :
135 : : /* Initialize a parent watch entry. */
136 : 0 : static struct audit_parent *audit_init_parent(struct path *path)
137 : : {
138 : 0 : struct inode *inode = d_backing_inode(path->dentry);
139 : : struct audit_parent *parent;
140 : : int ret;
141 : :
142 : 0 : parent = kzalloc(sizeof(*parent), GFP_KERNEL);
143 [ # # ]: 0 : if (unlikely(!parent))
144 : : return ERR_PTR(-ENOMEM);
145 : :
146 : 0 : INIT_LIST_HEAD(&parent->watches);
147 : :
148 : 0 : fsnotify_init_mark(&parent->mark, audit_watch_group);
149 : 0 : parent->mark.mask = AUDIT_FS_WATCH;
150 : : ret = fsnotify_add_inode_mark(&parent->mark, inode, 0);
151 [ # # ]: 0 : if (ret < 0) {
152 : 0 : audit_free_parent(parent);
153 : 0 : return ERR_PTR(ret);
154 : : }
155 : :
156 : : return parent;
157 : : }
158 : :
159 : : /* Initialize a watch entry. */
160 : 0 : static struct audit_watch *audit_init_watch(char *path)
161 : : {
162 : : struct audit_watch *watch;
163 : :
164 : 0 : watch = kzalloc(sizeof(*watch), GFP_KERNEL);
165 [ # # ]: 0 : if (unlikely(!watch))
166 : : return ERR_PTR(-ENOMEM);
167 : :
168 : 0 : INIT_LIST_HEAD(&watch->rules);
169 : : refcount_set(&watch->count, 1);
170 : 0 : watch->path = path;
171 : 0 : watch->dev = AUDIT_DEV_UNSET;
172 : 0 : watch->ino = AUDIT_INO_UNSET;
173 : :
174 : 0 : return watch;
175 : : }
176 : :
177 : : /* Translate a watch string to kernel representation. */
178 : 0 : int audit_to_watch(struct audit_krule *krule, char *path, int len, u32 op)
179 : : {
180 : : struct audit_watch *watch;
181 : :
182 [ # # ]: 0 : if (!audit_watch_group)
183 : : return -EOPNOTSUPP;
184 : :
185 [ # # # # : 0 : if (path[0] != '/' || path[len-1] == '/' ||
# # ]
186 [ # # ]: 0 : krule->listnr != AUDIT_FILTER_EXIT ||
187 [ # # ]: 0 : op != Audit_equal ||
188 [ # # # # ]: 0 : krule->inode_f || krule->watch || krule->tree)
189 : : return -EINVAL;
190 : :
191 : 0 : watch = audit_init_watch(path);
192 [ # # ]: 0 : if (IS_ERR(watch))
193 : 0 : return PTR_ERR(watch);
194 : :
195 : 0 : krule->watch = watch;
196 : :
197 : 0 : return 0;
198 : : }
199 : :
200 : : /* Duplicate the given audit watch. The new watch's rules list is initialized
201 : : * to an empty list and wlist is undefined. */
202 : 0 : static struct audit_watch *audit_dupe_watch(struct audit_watch *old)
203 : : {
204 : : char *path;
205 : : struct audit_watch *new;
206 : :
207 : 0 : path = kstrdup(old->path, GFP_KERNEL);
208 [ # # ]: 0 : if (unlikely(!path))
209 : : return ERR_PTR(-ENOMEM);
210 : :
211 : 0 : new = audit_init_watch(path);
212 [ # # ]: 0 : if (IS_ERR(new)) {
213 : 0 : kfree(path);
214 : 0 : goto out;
215 : : }
216 : :
217 : 0 : new->dev = old->dev;
218 : 0 : new->ino = old->ino;
219 : 0 : audit_get_parent(old->parent);
220 : 0 : new->parent = old->parent;
221 : :
222 : : out:
223 : 0 : return new;
224 : : }
225 : :
226 : 0 : static void audit_watch_log_rule_change(struct audit_krule *r, struct audit_watch *w, char *op)
227 : : {
228 : : struct audit_buffer *ab;
229 : :
230 [ # # ]: 0 : if (!audit_enabled)
231 : : return;
232 : 0 : ab = audit_log_start(audit_context(), GFP_NOFS, AUDIT_CONFIG_CHANGE);
233 [ # # ]: 0 : if (!ab)
234 : : return;
235 : 0 : audit_log_session_info(ab);
236 : 0 : audit_log_format(ab, "op=%s path=", op);
237 : 0 : audit_log_untrustedstring(ab, w->path);
238 : 0 : audit_log_key(ab, r->filterkey);
239 : 0 : audit_log_format(ab, " list=%d res=1", r->listnr);
240 : 0 : audit_log_end(ab);
241 : : }
242 : :
243 : : /* Update inode info in audit rules based on filesystem event. */
244 : 0 : static void audit_update_watch(struct audit_parent *parent,
245 : : const struct qstr *dname, dev_t dev,
246 : : unsigned long ino, unsigned invalidating)
247 : : {
248 : : struct audit_watch *owatch, *nwatch, *nextw;
249 : : struct audit_krule *r, *nextr;
250 : : struct audit_entry *oentry, *nentry;
251 : :
252 : 0 : mutex_lock(&audit_filter_mutex);
253 : : /* Run all of the watches on this parent looking for the one that
254 : : * matches the given dname */
255 [ # # ]: 0 : list_for_each_entry_safe(owatch, nextw, &parent->watches, wlist) {
256 [ # # ]: 0 : if (audit_compare_dname_path(dname, owatch->path,
257 : : AUDIT_NAME_FULL))
258 : 0 : continue;
259 : :
260 : : /* If the update involves invalidating rules, do the inode-based
261 : : * filtering now, so we don't omit records. */
262 [ # # # # ]: 0 : if (invalidating && !audit_dummy_context())
263 : 0 : audit_filter_inodes(current, audit_context());
264 : :
265 : : /* updating ino will likely change which audit_hash_list we
266 : : * are on so we need a new watch for the new list */
267 : 0 : nwatch = audit_dupe_watch(owatch);
268 [ # # ]: 0 : if (IS_ERR(nwatch)) {
269 : 0 : mutex_unlock(&audit_filter_mutex);
270 : 0 : audit_panic("error updating watch, skipping");
271 : 0 : return;
272 : : }
273 : 0 : nwatch->dev = dev;
274 : 0 : nwatch->ino = ino;
275 : :
276 [ # # ]: 0 : list_for_each_entry_safe(r, nextr, &owatch->rules, rlist) {
277 : :
278 : : oentry = container_of(r, struct audit_entry, rule);
279 : : list_del(&oentry->rule.rlist);
280 : : list_del_rcu(&oentry->list);
281 : :
282 : 0 : nentry = audit_dupe_rule(&oentry->rule);
283 [ # # ]: 0 : if (IS_ERR(nentry)) {
284 : : list_del(&oentry->rule.list);
285 : 0 : audit_panic("error updating watch, removing");
286 : : } else {
287 : : int h = audit_hash_ino((u32)ino);
288 : :
289 : : /*
290 : : * nentry->rule.watch == oentry->rule.watch so
291 : : * we must drop that reference and set it to our
292 : : * new watch.
293 : : */
294 : 0 : audit_put_watch(nentry->rule.watch);
295 : : audit_get_watch(nwatch);
296 : 0 : nentry->rule.watch = nwatch;
297 : 0 : list_add(&nentry->rule.rlist, &nwatch->rules);
298 : 0 : list_add_rcu(&nentry->list, &audit_inode_hash[h]);
299 : 0 : list_replace(&oentry->rule.list,
300 : : &nentry->rule.list);
301 : : }
302 [ # # ]: 0 : if (oentry->rule.exe)
303 : 0 : audit_remove_mark(oentry->rule.exe);
304 : :
305 : 0 : audit_watch_log_rule_change(r, owatch, "updated_rules");
306 : :
307 : 0 : call_rcu(&oentry->rcu, audit_free_rule_rcu);
308 : : }
309 : :
310 : 0 : audit_remove_watch(owatch);
311 : : goto add_watch_to_parent; /* event applies to a single watch */
312 : : }
313 : 0 : mutex_unlock(&audit_filter_mutex);
314 : 0 : return;
315 : :
316 : : add_watch_to_parent:
317 : 0 : list_add(&nwatch->wlist, &parent->watches);
318 : 0 : mutex_unlock(&audit_filter_mutex);
319 : 0 : return;
320 : : }
321 : :
322 : : /* Remove all watches & rules associated with a parent that is going away. */
323 : 0 : static void audit_remove_parent_watches(struct audit_parent *parent)
324 : : {
325 : : struct audit_watch *w, *nextw;
326 : : struct audit_krule *r, *nextr;
327 : : struct audit_entry *e;
328 : :
329 : 0 : mutex_lock(&audit_filter_mutex);
330 [ # # ]: 0 : list_for_each_entry_safe(w, nextw, &parent->watches, wlist) {
331 [ # # ]: 0 : list_for_each_entry_safe(r, nextr, &w->rules, rlist) {
332 : : e = container_of(r, struct audit_entry, rule);
333 : 0 : audit_watch_log_rule_change(r, w, "remove_rule");
334 [ # # ]: 0 : if (e->rule.exe)
335 : 0 : audit_remove_mark(e->rule.exe);
336 : : list_del(&r->rlist);
337 : : list_del(&r->list);
338 : : list_del_rcu(&e->list);
339 : 0 : call_rcu(&e->rcu, audit_free_rule_rcu);
340 : : }
341 : 0 : audit_remove_watch(w);
342 : : }
343 : 0 : mutex_unlock(&audit_filter_mutex);
344 : :
345 : 0 : fsnotify_destroy_mark(&parent->mark, audit_watch_group);
346 : 0 : }
347 : :
348 : : /* Get path information necessary for adding watches. */
349 : 0 : static int audit_get_nd(struct audit_watch *watch, struct path *parent)
350 : : {
351 : 0 : struct dentry *d = kern_path_locked(watch->path, parent);
352 [ # # ]: 0 : if (IS_ERR(d))
353 : 0 : return PTR_ERR(d);
354 [ # # ]: 0 : if (d_is_positive(d)) {
355 : : /* update watch filter fields */
356 : 0 : watch->dev = d->d_sb->s_dev;
357 : 0 : watch->ino = d_backing_inode(d)->i_ino;
358 : : }
359 : 0 : inode_unlock(d_backing_inode(parent->dentry));
360 : 0 : dput(d);
361 : 0 : return 0;
362 : : }
363 : :
364 : : /* Associate the given rule with an existing parent.
365 : : * Caller must hold audit_filter_mutex. */
366 : 0 : static void audit_add_to_parent(struct audit_krule *krule,
367 : : struct audit_parent *parent)
368 : : {
369 : 0 : struct audit_watch *w, *watch = krule->watch;
370 : : int watch_found = 0;
371 : :
372 [ # # ]: 0 : BUG_ON(!mutex_is_locked(&audit_filter_mutex));
373 : :
374 [ # # ]: 0 : list_for_each_entry(w, &parent->watches, wlist) {
375 [ # # ]: 0 : if (strcmp(watch->path, w->path))
376 : 0 : continue;
377 : :
378 : : watch_found = 1;
379 : :
380 : : /* put krule's ref to temporary watch */
381 : 0 : audit_put_watch(watch);
382 : :
383 : : audit_get_watch(w);
384 : 0 : krule->watch = watch = w;
385 : :
386 : : audit_put_parent(parent);
387 : : break;
388 : : }
389 : :
390 [ # # ]: 0 : if (!watch_found) {
391 : 0 : watch->parent = parent;
392 : :
393 : : audit_get_watch(watch);
394 : 0 : list_add(&watch->wlist, &parent->watches);
395 : : }
396 : 0 : list_add(&krule->rlist, &watch->rules);
397 : 0 : }
398 : :
399 : : /* Find a matching watch entry, or add this one.
400 : : * Caller must hold audit_filter_mutex. */
401 : 0 : int audit_add_watch(struct audit_krule *krule, struct list_head **list)
402 : : {
403 : 0 : struct audit_watch *watch = krule->watch;
404 : : struct audit_parent *parent;
405 : : struct path parent_path;
406 : : int h, ret = 0;
407 : :
408 : : /*
409 : : * When we will be calling audit_add_to_parent, krule->watch might have
410 : : * been updated and watch might have been freed.
411 : : * So we need to keep a reference of watch.
412 : : */
413 : : audit_get_watch(watch);
414 : :
415 : 0 : mutex_unlock(&audit_filter_mutex);
416 : :
417 : : /* Avoid calling path_lookup under audit_filter_mutex. */
418 : 0 : ret = audit_get_nd(watch, &parent_path);
419 : :
420 : : /* caller expects mutex locked */
421 : 0 : mutex_lock(&audit_filter_mutex);
422 : :
423 [ # # ]: 0 : if (ret) {
424 : 0 : audit_put_watch(watch);
425 : 0 : return ret;
426 : : }
427 : :
428 : : /* either find an old parent or attach a new one */
429 : 0 : parent = audit_find_parent(d_backing_inode(parent_path.dentry));
430 [ # # ]: 0 : if (!parent) {
431 : 0 : parent = audit_init_parent(&parent_path);
432 [ # # ]: 0 : if (IS_ERR(parent)) {
433 : : ret = PTR_ERR(parent);
434 : 0 : goto error;
435 : : }
436 : : }
437 : :
438 : 0 : audit_add_to_parent(krule, parent);
439 : :
440 : 0 : h = audit_hash_ino((u32)watch->ino);
441 : 0 : *list = &audit_inode_hash[h];
442 : : error:
443 : 0 : path_put(&parent_path);
444 : 0 : audit_put_watch(watch);
445 : 0 : return ret;
446 : : }
447 : :
448 : 0 : void audit_remove_watch_rule(struct audit_krule *krule)
449 : : {
450 : 0 : struct audit_watch *watch = krule->watch;
451 : 0 : struct audit_parent *parent = watch->parent;
452 : :
453 : : list_del(&krule->rlist);
454 : :
455 [ # # ]: 0 : if (list_empty(&watch->rules)) {
456 : : /*
457 : : * audit_remove_watch() drops our reference to 'parent' which
458 : : * can get freed. Grab our own reference to be safe.
459 : : */
460 : : audit_get_parent(parent);
461 : 0 : audit_remove_watch(watch);
462 [ # # ]: 0 : if (list_empty(&parent->watches))
463 : 0 : fsnotify_destroy_mark(&parent->mark, audit_watch_group);
464 : : audit_put_parent(parent);
465 : : }
466 : 0 : }
467 : :
468 : : /* Update watch data in audit rules based on fsnotify events. */
469 : 0 : static int audit_watch_handle_event(struct fsnotify_group *group,
470 : : struct inode *to_tell,
471 : : u32 mask, const void *data, int data_type,
472 : : const struct qstr *dname, u32 cookie,
473 : : struct fsnotify_iter_info *iter_info)
474 : : {
475 : : struct fsnotify_mark *inode_mark = fsnotify_iter_inode_mark(iter_info);
476 : : const struct inode *inode;
477 : : struct audit_parent *parent;
478 : :
479 : 0 : parent = container_of(inode_mark, struct audit_parent, mark);
480 : :
481 [ # # ]: 0 : BUG_ON(group != audit_watch_group);
482 : :
483 [ # # # ]: 0 : switch (data_type) {
484 : : case (FSNOTIFY_EVENT_PATH):
485 : 0 : inode = d_backing_inode(((const struct path *)data)->dentry);
486 : 0 : break;
487 : : case (FSNOTIFY_EVENT_INODE):
488 : : inode = (const struct inode *)data;
489 : : break;
490 : : default:
491 : 0 : BUG();
492 : : inode = NULL;
493 : : break;
494 : : }
495 : :
496 [ # # # # ]: 0 : if (mask & (FS_CREATE|FS_MOVED_TO) && inode)
497 : 0 : audit_update_watch(parent, dname, inode->i_sb->s_dev, inode->i_ino, 0);
498 [ # # ]: 0 : else if (mask & (FS_DELETE|FS_MOVED_FROM))
499 : 0 : audit_update_watch(parent, dname, AUDIT_DEV_UNSET, AUDIT_INO_UNSET, 1);
500 [ # # ]: 0 : else if (mask & (FS_DELETE_SELF|FS_UNMOUNT|FS_MOVE_SELF))
501 : 0 : audit_remove_parent_watches(parent);
502 : :
503 : 0 : return 0;
504 : : }
505 : :
506 : : static const struct fsnotify_ops audit_watch_fsnotify_ops = {
507 : : .handle_event = audit_watch_handle_event,
508 : : .free_mark = audit_watch_free_mark,
509 : : };
510 : :
511 : 207 : static int __init audit_watch_init(void)
512 : : {
513 : 207 : audit_watch_group = fsnotify_alloc_group(&audit_watch_fsnotify_ops);
514 [ - + ]: 207 : if (IS_ERR(audit_watch_group)) {
515 : 0 : audit_watch_group = NULL;
516 : 0 : audit_panic("cannot create audit fsnotify group");
517 : : }
518 : 207 : return 0;
519 : : }
520 : : device_initcall(audit_watch_init);
521 : :
522 : 0 : int audit_dupe_exe(struct audit_krule *new, struct audit_krule *old)
523 : : {
524 : : struct audit_fsnotify_mark *audit_mark;
525 : : char *pathname;
526 : :
527 : 0 : pathname = kstrdup(audit_mark_path(old->exe), GFP_KERNEL);
528 [ # # ]: 0 : if (!pathname)
529 : : return -ENOMEM;
530 : :
531 : 0 : audit_mark = audit_alloc_mark(new, pathname, strlen(pathname));
532 [ # # ]: 0 : if (IS_ERR(audit_mark)) {
533 : 0 : kfree(pathname);
534 : 0 : return PTR_ERR(audit_mark);
535 : : }
536 : 0 : new->exe = audit_mark;
537 : :
538 : 0 : return 0;
539 : : }
540 : :
541 : 0 : int audit_exe_compare(struct task_struct *tsk, struct audit_fsnotify_mark *mark)
542 : : {
543 : : struct file *exe_file;
544 : : unsigned long ino;
545 : : dev_t dev;
546 : :
547 : 0 : exe_file = get_task_exe_file(tsk);
548 [ # # ]: 0 : if (!exe_file)
549 : : return 0;
550 : 0 : ino = file_inode(exe_file)->i_ino;
551 : 0 : dev = file_inode(exe_file)->i_sb->s_dev;
552 : 0 : fput(exe_file);
553 : 0 : return audit_mark_compare(mark, ino, dev);
554 : : }
|
