root/kernel/audit_watch.c

DEFINITIONS

1. audit_free_parent
2. audit_watch_free_mark
3. audit_get_parent
4. audit_put_parent
5. audit_find_parent
6. audit_get_watch
7. audit_put_watch
8. audit_remove_watch
9. audit_watch_path
10. audit_watch_compare
11. audit_init_parent
12. audit_init_watch
13. audit_to_watch
14. audit_dupe_watch
15. audit_watch_log_rule_change
16. audit_update_watch
17. audit_remove_parent_watches
18. audit_get_nd
19. audit_add_to_parent
20. audit_add_watch
21. audit_remove_watch_rule
22. audit_watch_handle_event
23. audit_watch_init
24. audit_dupe_exe
25. audit_exe_compare

   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 static void audit_free_parent(struct audit_parent *parent)
  59 {
  60         WARN_ON(!list_empty(&parent->watches));
  61         kfree(parent);
  62 }
  63 
  64 static void audit_watch_free_mark(struct fsnotify_mark *entry)
  65 {
  66         struct audit_parent *parent;
  67 
  68         parent = container_of(entry, struct audit_parent, mark);
  69         audit_free_parent(parent);
  70 }
  71 
  72 static void audit_get_parent(struct audit_parent *parent)
  73 {
  74         if (likely(parent))
  75                 fsnotify_get_mark(&parent->mark);
  76 }
  77 
  78 static void audit_put_parent(struct audit_parent *parent)
  79 {
  80         if (likely(parent))
  81                 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         entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_watch_group);
  94         if (entry)
  95                 parent = container_of(entry, struct audit_parent, mark);
  96 
  97         return parent;
  98 }
  99 
 100 void audit_get_watch(struct audit_watch *watch)
 101 {
 102         refcount_inc(&watch->count);
 103 }
 104 
 105 void audit_put_watch(struct audit_watch *watch)
 106 {
 107         if (refcount_dec_and_test(&watch->count)) {
 108                 WARN_ON(watch->parent);
 109                 WARN_ON(!list_empty(&watch->rules));
 110                 kfree(watch->path);
 111                 kfree(watch);
 112         }
 113 }
 114 
 115 static void audit_remove_watch(struct audit_watch *watch)
 116 {
 117         list_del(&watch->wlist);
 118         audit_put_parent(watch->parent);
 119         watch->parent = NULL;
 120         audit_put_watch(watch); /* match initial get */
 121 }
 122 
 123 char *audit_watch_path(struct audit_watch *watch)
 124 {
 125         return watch->path;
 126 }
 127 
 128 int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
 129 {
 130         return (watch->ino != AUDIT_INO_UNSET) &&
 131                 (watch->ino == ino) &&
 132                 (watch->dev == dev);
 133 }
 134 
 135 /* Initialize a parent watch entry. */
 136 static struct audit_parent *audit_init_parent(struct path *path)
 137 {
 138         struct inode *inode = d_backing_inode(path->dentry);
 139         struct audit_parent *parent;
 140         int ret;
 141 
 142         parent = kzalloc(sizeof(*parent), GFP_KERNEL);
 143         if (unlikely(!parent))
 144                 return ERR_PTR(-ENOMEM);
 145 
 146         INIT_LIST_HEAD(&parent->watches);
 147 
 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);
 151         if (ret < 0) {
 152                 audit_free_parent(parent);
 153                 return ERR_PTR(ret);
 154         }
 155 
 156         return parent;
 157 }
 158 
 159 /* Initialize a watch entry. */
 160 static struct audit_watch *audit_init_watch(char *path)
 161 {
 162         struct audit_watch *watch;
 163 
 164         watch = kzalloc(sizeof(*watch), GFP_KERNEL);
 165         if (unlikely(!watch))
 166                 return ERR_PTR(-ENOMEM);
 167 
 168         INIT_LIST_HEAD(&watch->rules);
 169         refcount_set(&watch->count, 1);
 170         watch->path = path;
 171         watch->dev = AUDIT_DEV_UNSET;
 172         watch->ino = AUDIT_INO_UNSET;
 173 
 174         return watch;
 175 }
 176 
 177 /* Translate a watch string to kernel representation. */
 178 int audit_to_watch(struct audit_krule *krule, char *path, int len, u32 op)
 179 {
 180         struct audit_watch *watch;
 181 
 182         if (!audit_watch_group)
 183                 return -EOPNOTSUPP;
 184 
 185         if (path[0] != '/' || path[len-1] == '/' ||
 186             krule->listnr != AUDIT_FILTER_EXIT ||
 187             op != Audit_equal ||
 188             krule->inode_f || krule->watch || krule->tree)
 189                 return -EINVAL;
 190 
 191         watch = audit_init_watch(path);
 192         if (IS_ERR(watch))
 193                 return PTR_ERR(watch);
 194 
 195         krule->watch = watch;
 196 
 197         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 static struct audit_watch *audit_dupe_watch(struct audit_watch *old)
 203 {
 204         char *path;
 205         struct audit_watch *new;
 206 
 207         path = kstrdup(old->path, GFP_KERNEL);
 208         if (unlikely(!path))
 209                 return ERR_PTR(-ENOMEM);
 210 
 211         new = audit_init_watch(path);
 212         if (IS_ERR(new)) {
 213                 kfree(path);
 214                 goto out;
 215         }
 216 
 217         new->dev = old->dev;
 218         new->ino = old->ino;
 219         audit_get_parent(old->parent);
 220         new->parent = old->parent;
 221 
 222 out:
 223         return new;
 224 }
 225 
 226 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         if (!audit_enabled)
 231                 return;
 232         ab = audit_log_start(audit_context(), GFP_NOFS, AUDIT_CONFIG_CHANGE);
 233         if (!ab)
 234                 return;
 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);
 240         audit_log_end(ab);
 241 }
 242 
 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)
 247 {
 248         struct audit_watch *owatch, *nwatch, *nextw;
 249         struct audit_krule *r, *nextr;
 250         struct audit_entry *oentry, *nentry;
 251 
 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,
 257                                              AUDIT_NAME_FULL))
 258                         continue;
 259 
 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());
 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                 nwatch = audit_dupe_watch(owatch);
 268                 if (IS_ERR(nwatch)) {
 269                         mutex_unlock(&audit_filter_mutex);
 270                         audit_panic("error updating watch, skipping");
 271                         return;
 272                 }
 273                 nwatch->dev = dev;
 274                 nwatch->ino = ino;
 275 
 276                 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                         nentry = audit_dupe_rule(&oentry->rule);
 283                         if (IS_ERR(nentry)) {
 284                                 list_del(&oentry->rule.list);
 285                                 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                                 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,
 300                                              &nentry->rule.list);
 301                         }
 302                         if (oentry->rule.exe)
 303                                 audit_remove_mark(oentry->rule.exe);
 304 
 305                         audit_watch_log_rule_change(r, owatch, "updated_rules");
 306 
 307                         call_rcu(&oentry->rcu, audit_free_rule_rcu);
 308                 }
 309 
 310                 audit_remove_watch(owatch);
 311                 goto add_watch_to_parent; /* event applies to a single watch */
 312         }
 313         mutex_unlock(&audit_filter_mutex);
 314         return;
 315 
 316 add_watch_to_parent:
 317         list_add(&nwatch->wlist, &parent->watches);
 318         mutex_unlock(&audit_filter_mutex);
 319         return;
 320 }
 321 
 322 /* Remove all watches & rules associated with a parent that is going away. */
 323 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         mutex_lock(&audit_filter_mutex);
 330         list_for_each_entry_safe(w, nextw, &parent->watches, wlist) {
 331                 list_for_each_entry_safe(r, nextr, &w->rules, rlist) {
 332                         e = container_of(r, struct audit_entry, rule);
 333                         audit_watch_log_rule_change(r, w, "remove_rule");
 334                         if (e->rule.exe)
 335                                 audit_remove_mark(e->rule.exe);
 336                         list_del(&r->rlist);
 337                         list_del(&r->list);
 338                         list_del_rcu(&e->list);
 339                         call_rcu(&e->rcu, audit_free_rule_rcu);
 340                 }
 341                 audit_remove_watch(w);
 342         }
 343         mutex_unlock(&audit_filter_mutex);
 344 
 345         fsnotify_destroy_mark(&parent->mark, audit_watch_group);
 346 }
 347 
 348 /* Get path information necessary for adding watches. */
 349 static int audit_get_nd(struct audit_watch *watch, struct path *parent)
 350 {
 351         struct dentry *d = kern_path_locked(watch->path, parent);
 352         if (IS_ERR(d))
 353                 return PTR_ERR(d);
 354         if (d_is_positive(d)) {
 355                 /* update watch filter fields */
 356                 watch->dev = d->d_sb->s_dev;
 357                 watch->ino = d_backing_inode(d)->i_ino;
 358         }
 359         inode_unlock(d_backing_inode(parent->dentry));
 360         dput(d);
 361         return 0;
 362 }
 363 
 364 /* Associate the given rule with an existing parent.
 365  * Caller must hold audit_filter_mutex. */
 366 static void audit_add_to_parent(struct audit_krule *krule,
 367                                 struct audit_parent *parent)
 368 {
 369         struct audit_watch *w, *watch = krule->watch;
 370         int watch_found = 0;
 371 
 372         BUG_ON(!mutex_is_locked(&audit_filter_mutex));
 373 
 374         list_for_each_entry(w, &parent->watches, wlist) {
 375                 if (strcmp(watch->path, w->path))
 376                         continue;
 377 
 378                 watch_found = 1;
 379 
 380                 /* put krule's ref to temporary watch */
 381                 audit_put_watch(watch);
 382 
 383                 audit_get_watch(w);
 384                 krule->watch = watch = w;
 385 
 386                 audit_put_parent(parent);
 387                 break;
 388         }
 389 
 390         if (!watch_found) {
 391                 watch->parent = parent;
 392 
 393                 audit_get_watch(watch);
 394                 list_add(&watch->wlist, &parent->watches);
 395         }
 396         list_add(&krule->rlist, &watch->rules);
 397 }
 398 
 399 /* Find a matching watch entry, or add this one.
 400  * Caller must hold audit_filter_mutex. */
 401 int audit_add_watch(struct audit_krule *krule, struct list_head **list)
 402 {
 403         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         mutex_unlock(&audit_filter_mutex);
 416 
 417         /* Avoid calling path_lookup under audit_filter_mutex. */
 418         ret = audit_get_nd(watch, &parent_path);
 419 
 420         /* caller expects mutex locked */
 421         mutex_lock(&audit_filter_mutex);
 422 
 423         if (ret) {
 424                 audit_put_watch(watch);
 425                 return ret;
 426         }
 427 
 428         /* either find an old parent or attach a new one */
 429         parent = audit_find_parent(d_backing_inode(parent_path.dentry));
 430         if (!parent) {
 431                 parent = audit_init_parent(&parent_path);
 432                 if (IS_ERR(parent)) {
 433                         ret = PTR_ERR(parent);
 434                         goto error;
 435                 }
 436         }
 437 
 438         audit_add_to_parent(krule, parent);
 439 
 440         h = audit_hash_ino((u32)watch->ino);
 441         *list = &audit_inode_hash[h];
 442 error:
 443         path_put(&parent_path);
 444         audit_put_watch(watch);
 445         return ret;
 446 }
 447 
 448 void audit_remove_watch_rule(struct audit_krule *krule)
 449 {
 450         struct audit_watch *watch = krule->watch;
 451         struct audit_parent *parent = watch->parent;
 452 
 453         list_del(&krule->rlist);
 454 
 455         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                 audit_remove_watch(watch);
 462                 if (list_empty(&parent->watches))
 463                         fsnotify_destroy_mark(&parent->mark, audit_watch_group);
 464                 audit_put_parent(parent);
 465         }
 466 }
 467 
 468 /* Update watch data in audit rules based on fsnotify events. */
 469 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         parent = container_of(inode_mark, struct audit_parent, mark);
 480 
 481         BUG_ON(group != audit_watch_group);
 482 
 483         switch (data_type) {
 484         case (FSNOTIFY_EVENT_PATH):
 485                 inode = d_backing_inode(((const struct path *)data)->dentry);
 486                 break;
 487         case (FSNOTIFY_EVENT_INODE):
 488                 inode = (const struct inode *)data;
 489                 break;
 490         default:
 491                 BUG();
 492                 inode = NULL;
 493                 break;
 494         }
 495 
 496         if (mask & (FS_CREATE|FS_MOVED_TO) && inode)
 497                 audit_update_watch(parent, dname, inode->i_sb->s_dev, inode->i_ino, 0);
 498         else if (mask & (FS_DELETE|FS_MOVED_FROM))
 499                 audit_update_watch(parent, dname, AUDIT_DEV_UNSET, AUDIT_INO_UNSET, 1);
 500         else if (mask & (FS_DELETE_SELF|FS_UNMOUNT|FS_MOVE_SELF))
 501                 audit_remove_parent_watches(parent);
 502 
 503         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 static int __init audit_watch_init(void)
 512 {
 513         audit_watch_group = fsnotify_alloc_group(&audit_watch_fsnotify_ops);
 514         if (IS_ERR(audit_watch_group)) {
 515                 audit_watch_group = NULL;
 516                 audit_panic("cannot create audit fsnotify group");
 517         }
 518         return 0;
 519 }
 520 device_initcall(audit_watch_init);
 521 
 522 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         pathname = kstrdup(audit_mark_path(old->exe), GFP_KERNEL);
 528         if (!pathname)
 529                 return -ENOMEM;
 530 
 531         audit_mark = audit_alloc_mark(new, pathname, strlen(pathname));
 532         if (IS_ERR(audit_mark)) {
 533                 kfree(pathname);
 534                 return PTR_ERR(audit_mark);
 535         }
 536         new->exe = audit_mark;
 537 
 538         return 0;
 539 }
 540 
 541 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         exe_file = get_task_exe_file(tsk);
 548         if (!exe_file)
 549                 return 0;
 550         ino = file_inode(exe_file)->i_ino;
 551         dev = file_inode(exe_file)->i_sb->s_dev;
 552         fput(exe_file);
 553         return audit_mark_compare(mark, ino, dev);
 554 }