1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* audit_watch.c -- watching inodes
4 * Copyright 2003-2009 Red Hat, Inc.
5 * Copyright 2005 Hewlett-Packard Development Company, L.P.
6 * Copyright 2005 IBM Corporation
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>
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>
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.
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.
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 */
47 struct list_head watches; /* anchor for audit_watch->wlist */
48 struct fsnotify_mark mark; /* fsnotify mark on the inode */
51 /* fsnotify handle. */
52 static struct fsnotify_group *audit_watch_group;
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_UNMOUNT)
58 static void audit_free_parent(struct audit_parent *parent)
60 WARN_ON(!list_empty(&parent->watches));
64 static void audit_watch_free_mark(struct fsnotify_mark *entry)
66 struct audit_parent *parent;
68 parent = container_of(entry, struct audit_parent, mark);
69 audit_free_parent(parent);
72 static void audit_get_parent(struct audit_parent *parent)
75 fsnotify_get_mark(&parent->mark);
78 static void audit_put_parent(struct audit_parent *parent)
81 fsnotify_put_mark(&parent->mark);
85 * Find and return the audit_parent on the given inode. If found a reference
86 * is taken on this parent.
88 static inline struct audit_parent *audit_find_parent(struct inode *inode)
90 struct audit_parent *parent = NULL;
91 struct fsnotify_mark *entry;
93 entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_watch_group);
95 parent = container_of(entry, struct audit_parent, mark);
100 void audit_get_watch(struct audit_watch *watch)
102 refcount_inc(&watch->count);
105 void audit_put_watch(struct audit_watch *watch)
107 if (refcount_dec_and_test(&watch->count)) {
108 WARN_ON(watch->parent);
109 WARN_ON(!list_empty(&watch->rules));
115 static void audit_remove_watch(struct audit_watch *watch)
117 list_del(&watch->wlist);
118 audit_put_parent(watch->parent);
119 watch->parent = NULL;
120 audit_put_watch(watch); /* match initial get */
123 char *audit_watch_path(struct audit_watch *watch)
128 int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
130 return (watch->ino != AUDIT_INO_UNSET) &&
131 (watch->ino == ino) &&
135 /* Initialize a parent watch entry. */
136 static struct audit_parent *audit_init_parent(struct path *path)
138 struct inode *inode = d_backing_inode(path->dentry);
139 struct audit_parent *parent;
142 parent = kzalloc(sizeof(*parent), GFP_KERNEL);
143 if (unlikely(!parent))
144 return ERR_PTR(-ENOMEM);
146 INIT_LIST_HEAD(&parent->watches);
148 fsnotify_init_mark(&parent->mark, audit_watch_group);
149 parent->mark.mask = AUDIT_FS_WATCH;
150 ret = fsnotify_add_inode_mark(&parent->mark, inode, 0);
152 audit_free_parent(parent);
159 /* Initialize a watch entry. */
160 static struct audit_watch *audit_init_watch(char *path)
162 struct audit_watch *watch;
164 watch = kzalloc(sizeof(*watch), GFP_KERNEL);
165 if (unlikely(!watch))
166 return ERR_PTR(-ENOMEM);
168 INIT_LIST_HEAD(&watch->rules);
169 refcount_set(&watch->count, 1);
171 watch->dev = AUDIT_DEV_UNSET;
172 watch->ino = AUDIT_INO_UNSET;
177 /* Translate a watch string to kernel representation. */
178 int audit_to_watch(struct audit_krule *krule, char *path, int len, u32 op)
180 struct audit_watch *watch;
182 if (!audit_watch_group)
185 if (path[0] != '/' || path[len-1] == '/' ||
186 krule->listnr != AUDIT_FILTER_EXIT ||
188 krule->inode_f || krule->watch || krule->tree)
191 watch = audit_init_watch(path);
193 return PTR_ERR(watch);
195 krule->watch = watch;
200 /* Duplicate the given audit watch. The new watch's rules list is initialized
201 * to an empty list and wlist is undefined. */
202 static struct audit_watch *audit_dupe_watch(struct audit_watch *old)
205 struct audit_watch *new;
207 path = kstrdup(old->path, GFP_KERNEL);
209 return ERR_PTR(-ENOMEM);
211 new = audit_init_watch(path);
219 audit_get_parent(old->parent);
220 new->parent = old->parent;
226 static void audit_watch_log_rule_change(struct audit_krule *r, struct audit_watch *w, char *op)
228 struct audit_buffer *ab;
232 ab = audit_log_start(audit_context(), GFP_NOFS, AUDIT_CONFIG_CHANGE);
235 audit_log_session_info(ab);
236 audit_log_format(ab, "op=%s path=", op);
237 audit_log_untrustedstring(ab, w->path);
238 audit_log_key(ab, r->filterkey);
239 audit_log_format(ab, " list=%d res=1", r->listnr);
243 /* Update inode info in audit rules based on filesystem event. */
244 static void audit_update_watch(struct audit_parent *parent,
245 const struct qstr *dname, dev_t dev,
246 unsigned long ino, unsigned invalidating)
248 struct audit_watch *owatch, *nwatch, *nextw;
249 struct audit_krule *r, *nextr;
250 struct audit_entry *oentry, *nentry;
252 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 list_for_each_entry_safe(owatch, nextw, &parent->watches, wlist) {
256 if (audit_compare_dname_path(dname, owatch->path,
260 /* If the update involves invalidating rules, do the inode-based
261 * filtering now, so we don't omit records. */
262 if (invalidating && !audit_dummy_context())
263 audit_filter_inodes(current, audit_context());
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 nwatch = audit_dupe_watch(owatch);
268 if (IS_ERR(nwatch)) {
269 mutex_unlock(&audit_filter_mutex);
270 audit_panic("error updating watch, skipping");
276 list_for_each_entry_safe(r, nextr, &owatch->rules, rlist) {
278 oentry = container_of(r, struct audit_entry, rule);
279 list_del(&oentry->rule.rlist);
280 list_del_rcu(&oentry->list);
282 nentry = audit_dupe_rule(&oentry->rule);
283 if (IS_ERR(nentry)) {
284 list_del(&oentry->rule.list);
285 audit_panic("error updating watch, removing");
287 int h = audit_hash_ino((u32)ino);
290 * nentry->rule.watch == oentry->rule.watch so
291 * we must drop that reference and set it to our
294 audit_put_watch(nentry->rule.watch);
295 audit_get_watch(nwatch);
296 nentry->rule.watch = nwatch;
297 list_add(&nentry->rule.rlist, &nwatch->rules);
298 list_add_rcu(&nentry->list, &audit_inode_hash[h]);
299 list_replace(&oentry->rule.list,
302 if (oentry->rule.exe)
303 audit_remove_mark(oentry->rule.exe);
305 call_rcu(&oentry->rcu, audit_free_rule_rcu);
308 audit_remove_watch(owatch);
309 goto add_watch_to_parent; /* event applies to a single watch */
311 mutex_unlock(&audit_filter_mutex);
315 list_add(&nwatch->wlist, &parent->watches);
316 mutex_unlock(&audit_filter_mutex);
320 /* Remove all watches & rules associated with a parent that is going away. */
321 static void audit_remove_parent_watches(struct audit_parent *parent)
323 struct audit_watch *w, *nextw;
324 struct audit_krule *r, *nextr;
325 struct audit_entry *e;
327 mutex_lock(&audit_filter_mutex);
328 list_for_each_entry_safe(w, nextw, &parent->watches, wlist) {
329 list_for_each_entry_safe(r, nextr, &w->rules, rlist) {
330 e = container_of(r, struct audit_entry, rule);
331 audit_watch_log_rule_change(r, w, "remove_rule");
333 audit_remove_mark(e->rule.exe);
336 list_del_rcu(&e->list);
337 call_rcu(&e->rcu, audit_free_rule_rcu);
339 audit_remove_watch(w);
341 mutex_unlock(&audit_filter_mutex);
343 fsnotify_destroy_mark(&parent->mark, audit_watch_group);
346 /* Get path information necessary for adding watches. */
347 static int audit_get_nd(struct audit_watch *watch, struct path *parent)
349 struct dentry *d = kern_path_locked(watch->path, parent);
352 if (d_is_positive(d)) {
353 /* update watch filter fields */
354 watch->dev = d->d_sb->s_dev;
355 watch->ino = d_backing_inode(d)->i_ino;
357 inode_unlock(d_backing_inode(parent->dentry));
362 /* Associate the given rule with an existing parent.
363 * Caller must hold audit_filter_mutex. */
364 static void audit_add_to_parent(struct audit_krule *krule,
365 struct audit_parent *parent)
367 struct audit_watch *w, *watch = krule->watch;
370 BUG_ON(!mutex_is_locked(&audit_filter_mutex));
372 list_for_each_entry(w, &parent->watches, wlist) {
373 if (strcmp(watch->path, w->path))
378 /* put krule's ref to temporary watch */
379 audit_put_watch(watch);
382 krule->watch = watch = w;
384 audit_put_parent(parent);
389 watch->parent = parent;
391 audit_get_watch(watch);
392 list_add(&watch->wlist, &parent->watches);
394 list_add(&krule->rlist, &watch->rules);
397 /* Find a matching watch entry, or add this one.
398 * Caller must hold audit_filter_mutex. */
399 int audit_add_watch(struct audit_krule *krule, struct list_head **list)
401 struct audit_watch *watch = krule->watch;
402 struct audit_parent *parent;
403 struct path parent_path;
407 * When we will be calling audit_add_to_parent, krule->watch might have
408 * been updated and watch might have been freed.
409 * So we need to keep a reference of watch.
411 audit_get_watch(watch);
413 mutex_unlock(&audit_filter_mutex);
415 /* Avoid calling path_lookup under audit_filter_mutex. */
416 ret = audit_get_nd(watch, &parent_path);
418 /* caller expects mutex locked */
419 mutex_lock(&audit_filter_mutex);
422 audit_put_watch(watch);
426 /* either find an old parent or attach a new one */
427 parent = audit_find_parent(d_backing_inode(parent_path.dentry));
429 parent = audit_init_parent(&parent_path);
430 if (IS_ERR(parent)) {
431 ret = PTR_ERR(parent);
436 audit_add_to_parent(krule, parent);
438 h = audit_hash_ino((u32)watch->ino);
439 *list = &audit_inode_hash[h];
441 path_put(&parent_path);
442 audit_put_watch(watch);
446 void audit_remove_watch_rule(struct audit_krule *krule)
448 struct audit_watch *watch = krule->watch;
449 struct audit_parent *parent = watch->parent;
451 list_del(&krule->rlist);
453 if (list_empty(&watch->rules)) {
455 * audit_remove_watch() drops our reference to 'parent' which
456 * can get freed. Grab our own reference to be safe.
458 audit_get_parent(parent);
459 audit_remove_watch(watch);
460 if (list_empty(&parent->watches))
461 fsnotify_destroy_mark(&parent->mark, audit_watch_group);
462 audit_put_parent(parent);
466 /* Update watch data in audit rules based on fsnotify events. */
467 static int audit_watch_handle_event(struct fsnotify_mark *inode_mark, u32 mask,
468 struct inode *inode, struct inode *dir,
469 const struct qstr *dname)
471 struct audit_parent *parent;
473 parent = container_of(inode_mark, struct audit_parent, mark);
475 if (WARN_ON_ONCE(inode_mark->group != audit_watch_group) ||
476 WARN_ON_ONCE(!inode))
479 if (mask & (FS_CREATE|FS_MOVED_TO) && inode)
480 audit_update_watch(parent, dname, inode->i_sb->s_dev, inode->i_ino, 0);
481 else if (mask & (FS_DELETE|FS_MOVED_FROM))
482 audit_update_watch(parent, dname, AUDIT_DEV_UNSET, AUDIT_INO_UNSET, 1);
483 else if (mask & (FS_DELETE_SELF|FS_UNMOUNT|FS_MOVE_SELF))
484 audit_remove_parent_watches(parent);
489 static const struct fsnotify_ops audit_watch_fsnotify_ops = {
490 .handle_inode_event = audit_watch_handle_event,
491 .free_mark = audit_watch_free_mark,
494 static int __init audit_watch_init(void)
496 audit_watch_group = fsnotify_alloc_group(&audit_watch_fsnotify_ops);
497 if (IS_ERR(audit_watch_group)) {
498 audit_watch_group = NULL;
499 audit_panic("cannot create audit fsnotify group");
503 device_initcall(audit_watch_init);
505 int audit_dupe_exe(struct audit_krule *new, struct audit_krule *old)
507 struct audit_fsnotify_mark *audit_mark;
510 pathname = kstrdup(audit_mark_path(old->exe), GFP_KERNEL);
514 audit_mark = audit_alloc_mark(new, pathname, strlen(pathname));
515 if (IS_ERR(audit_mark)) {
517 return PTR_ERR(audit_mark);
519 new->exe = audit_mark;
524 int audit_exe_compare(struct task_struct *tsk, struct audit_fsnotify_mark *mark)
526 struct file *exe_file;
530 exe_file = get_task_exe_file(tsk);
533 ino = file_inode(exe_file)->i_ino;
534 dev = file_inode(exe_file)->i_sb->s_dev;
536 return audit_mark_compare(mark, ino, dev);