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