kernel/auditfilter.c

   1 /* auditfilter.c -- filtering of audit events
   2  *
   3  * Copyright 2003-2004 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/kernel.h>
  23 #include <linux/audit.h>
  24 #include <linux/kthread.h>
  25 #include <linux/netlink.h>
  26 #include <linux/selinux.h>
  27 #include "audit.h"
  28
  29 /* There are three lists of rules -- one to search at task creation
  30  * time, one to search at syscall entry time, and another to search at
  31  * syscall exit time. */
  32 struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
  33         LIST_HEAD_INIT(audit_filter_list[0]),
  34         LIST_HEAD_INIT(audit_filter_list[1]),
  35         LIST_HEAD_INIT(audit_filter_list[2]),
  36         LIST_HEAD_INIT(audit_filter_list[3]),
  37         LIST_HEAD_INIT(audit_filter_list[4]),
  38         LIST_HEAD_INIT(audit_filter_list[5]),
  39 #if AUDIT_NR_FILTERS != 6
  40 #error Fix audit_filter_list initialiser
  41 #endif
  42 };
  43
  44 static inline void audit_free_rule(struct audit_entry *e)
  45 {
  46         int i;
  47         if (e->rule.fields)
  48                 for (i = 0; i < e->rule.field_count; i++) {
  49                         struct audit_field *f = &e->rule.fields[i];
  50                         kfree(f->se_str);
  51                         selinux_audit_rule_free(f->se_rule);
  52                 }
  53         kfree(e->rule.fields);
  54         kfree(e);
  55 }
  56
  57 static inline void audit_free_rule_rcu(struct rcu_head *head)
  58 {
  59         struct audit_entry *e = container_of(head, struct audit_entry, rcu);
  60         audit_free_rule(e);
  61 }
  62
  63 /* Initialize an audit filterlist entry. */
  64 static inline struct audit_entry *audit_init_entry(u32 field_count)
  65 {
  66         struct audit_entry *entry;
  67         struct audit_field *fields;
  68
  69         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
  70         if (unlikely(!entry))
  71                 return NULL;
  72
  73         fields = kzalloc(sizeof(*fields) * field_count, GFP_KERNEL);
  74         if (unlikely(!fields)) {
  75                 kfree(entry);
  76                 return NULL;
  77         }
  78         entry->rule.fields = fields;
  79
  80         return entry;
  81 }
  82
  83 /* Unpack a filter field's string representation from user-space
  84  * buffer. */
  85 static char *audit_unpack_string(void **bufp, size_t *remain, size_t len)
  86 {
  87         char *str;
  88
  89         if (!*bufp || (len == 0) || (len > *remain))
  90                 return ERR_PTR(-EINVAL);
  91
  92         /* Of the currently implemented string fields, PATH_MAX
  93          * defines the longest valid length.
  94          */
  95         if (len > PATH_MAX)
  96                 return ERR_PTR(-ENAMETOOLONG);
  97
  98         str = kmalloc(len + 1, GFP_KERNEL);
  99         if (unlikely(!str))
 100                 return ERR_PTR(-ENOMEM);
 101
 102         memcpy(str, *bufp, len);
 103         str[len] = 0;
 104         *bufp += len;
 105         *remain -= len;
 106
 107         return str;
 108 }
 109
 110 /* Common user-space to kernel rule translation. */
 111 static inline struct audit_entry *audit_to_entry_common(struct audit_rule *rule)
 112 {
 113         unsigned listnr;
 114         struct audit_entry *entry;
 115         int i, err;
 116
 117         err = -EINVAL;
 118         listnr = rule->flags & ~AUDIT_FILTER_PREPEND;
 119         switch(listnr) {
 120         default:
 121                 goto exit_err;
 122         case AUDIT_FILTER_USER:
 123         case AUDIT_FILTER_TYPE:
 124 #ifdef CONFIG_AUDITSYSCALL
 125         case AUDIT_FILTER_ENTRY:
 126         case AUDIT_FILTER_EXIT:
 127         case AUDIT_FILTER_TASK:
 128 #endif
 129                 ;
 130         }
 131         if (rule->action != AUDIT_NEVER && rule->action != AUDIT_POSSIBLE &&
 132             rule->action != AUDIT_ALWAYS)
 133                 goto exit_err;
 134         if (rule->field_count > AUDIT_MAX_FIELDS)
 135                 goto exit_err;
 136
 137         err = -ENOMEM;
 138         entry = audit_init_entry(rule->field_count);
 139         if (!entry)
 140                 goto exit_err;
 141
 142         entry->rule.flags = rule->flags & AUDIT_FILTER_PREPEND;
 143         entry->rule.listnr = listnr;
 144         entry->rule.action = rule->action;
 145         entry->rule.field_count = rule->field_count;
 146
 147         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
 148                 entry->rule.mask[i] = rule->mask[i];
 149
 150         return entry;
 151
 152 exit_err:
 153         return ERR_PTR(err);
 154 }
 155
 156 /* Translate struct audit_rule to kernel's rule respresentation.
 157  * Exists for backward compatibility with userspace. */
 158 static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
 159 {
 160         struct audit_entry *entry;
 161         int err = 0;
 162         int i;
 163
 164         entry = audit_to_entry_common(rule);
 165         if (IS_ERR(entry))
 166                 goto exit_nofree;
 167
 168         for (i = 0; i < rule->field_count; i++) {
 169                 struct audit_field *f = &entry->rule.fields[i];
 170
 171                 f->op = rule->fields[i] & (AUDIT_NEGATE|AUDIT_OPERATORS);
 172                 f->type = rule->fields[i] & ~(AUDIT_NEGATE|AUDIT_OPERATORS);
 173                 f->val = rule->values[i];
 174
 175                 if (f->type & AUDIT_UNUSED_BITS ||
 176                     f->type == AUDIT_SE_USER ||
 177                     f->type == AUDIT_SE_ROLE ||
 178                     f->type == AUDIT_SE_TYPE ||
 179                     f->type == AUDIT_SE_SEN ||
 180                     f->type == AUDIT_SE_CLR) {
 181                         err = -EINVAL;
 182                         goto exit_free;
 183                 }
 184
 185                 entry->rule.vers_ops = (f->op & AUDIT_OPERATORS) ? 2 : 1;
 186
 187                 /* Support for legacy operators where
 188                  * AUDIT_NEGATE bit signifies != and otherwise assumes == */
 189                 if (f->op & AUDIT_NEGATE)
 190                         f->op = AUDIT_NOT_EQUAL;
 191                 else if (!f->op)
 192                         f->op = AUDIT_EQUAL;
 193                 else if (f->op == AUDIT_OPERATORS) {
 194                         err = -EINVAL;
 195                         goto exit_free;
 196                 }
 197         }
 198
 199 exit_nofree:
 200         return entry;
 201
 202 exit_free:
 203         audit_free_rule(entry);
 204         return ERR_PTR(err);
 205 }
 206
 207 /* Translate struct audit_rule_data to kernel's rule respresentation. */
 208 static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
 209                                                size_t datasz)
 210 {
 211         int err = 0;
 212         struct audit_entry *entry;
 213         void *bufp;
 214         size_t remain = datasz - sizeof(struct audit_rule_data);
 215         int i;
 216         char *str;
 217
 218         entry = audit_to_entry_common((struct audit_rule *)data);
 219         if (IS_ERR(entry))
 220                 goto exit_nofree;
 221
 222         bufp = data->buf;
 223         entry->rule.vers_ops = 2;
 224         for (i = 0; i < data->field_count; i++) {
 225                 struct audit_field *f = &entry->rule.fields[i];
 226
 227                 err = -EINVAL;
 228                 if (!(data->fieldflags[i] & AUDIT_OPERATORS) ||
 229                     data->fieldflags[i] & ~AUDIT_OPERATORS)
 230                         goto exit_free;
 231
 232                 f->op = data->fieldflags[i] & AUDIT_OPERATORS;
 233                 f->type = data->fields[i];
 234                 f->val = data->values[i];
 235                 f->se_str = NULL;
 236                 f->se_rule = NULL;
 237                 switch(f->type) {
 238                 case AUDIT_SE_USER:
 239                 case AUDIT_SE_ROLE:
 240                 case AUDIT_SE_TYPE:
 241                 case AUDIT_SE_SEN:
 242                 case AUDIT_SE_CLR:
 243                         str = audit_unpack_string(&bufp, &remain, f->val);
 244                         if (IS_ERR(str))
 245                                 goto exit_free;
 246                         entry->rule.buflen += f->val;
 247
 248                         err = selinux_audit_rule_init(f->type, f->op, str,
 249                                                       &f->se_rule);
 250                         /* Keep currently invalid fields around in case they
 251                          * become valid after a policy reload. */
 252                         if (err == -EINVAL) {
 253                                 printk(KERN_WARNING "audit rule for selinux "
 254                                        "\'%s\' is invalid\n",  str);
 255                                 err = 0;
 256                         }
 257                         if (err) {
 258                                 kfree(str);
 259                                 goto exit_free;
 260                         } else
 261                                 f->se_str = str;
 262                         break;
 263                 }
 264         }
 265
 266 exit_nofree:
 267         return entry;
 268
 269 exit_free:
 270         audit_free_rule(entry);
 271         return ERR_PTR(err);
 272 }
 273
 274 /* Pack a filter field's string representation into data block. */
 275 static inline size_t audit_pack_string(void **bufp, char *str)
 276 {
 277         size_t len = strlen(str);
 278
 279         memcpy(*bufp, str, len);
 280         *bufp += len;
 281
 282         return len;
 283 }
 284
 285 /* Translate kernel rule respresentation to struct audit_rule.
 286  * Exists for backward compatibility with userspace. */
 287 static struct audit_rule *audit_krule_to_rule(struct audit_krule *krule)
 288 {
 289         struct audit_rule *rule;
 290         int i;
 291
 292         rule = kmalloc(sizeof(*rule), GFP_KERNEL);
 293         if (unlikely(!rule))
 294                 return ERR_PTR(-ENOMEM);
 295         memset(rule, 0, sizeof(*rule));
 296
 297         rule->flags = krule->flags | krule->listnr;
 298         rule->action = krule->action;
 299         rule->field_count = krule->field_count;
 300         for (i = 0; i < rule->field_count; i++) {
 301                 rule->values[i] = krule->fields[i].val;
 302                 rule->fields[i] = krule->fields[i].type;
 303
 304                 if (krule->vers_ops == 1) {
 305                         if (krule->fields[i].op & AUDIT_NOT_EQUAL)
 306                                 rule->fields[i] |= AUDIT_NEGATE;
 307                 } else {
 308                         rule->fields[i] |= krule->fields[i].op;
 309                 }
 310         }
 311         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) rule->mask[i] = krule->mask[i];
 312
 313         return rule;
 314 }
 315
 316 /* Translate kernel rule respresentation to struct audit_rule_data. */
 317 static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
 318 {
 319         struct audit_rule_data *data;
 320         void *bufp;
 321         int i;
 322
 323         data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
 324         if (unlikely(!data))
 325                 return ERR_PTR(-ENOMEM);
 326         memset(data, 0, sizeof(*data));
 327
 328         data->flags = krule->flags | krule->listnr;
 329         data->action = krule->action;
 330         data->field_count = krule->field_count;
 331         bufp = data->buf;
 332         for (i = 0; i < data->field_count; i++) {
 333                 struct audit_field *f = &krule->fields[i];
 334
 335                 data->fields[i] = f->type;
 336                 data->fieldflags[i] = f->op;
 337                 switch(f->type) {
 338                 case AUDIT_SE_USER:
 339                 case AUDIT_SE_ROLE:
 340                 case AUDIT_SE_TYPE:
 341                 case AUDIT_SE_SEN:
 342                 case AUDIT_SE_CLR:
 343                         data->buflen += data->values[i] =
 344                                 audit_pack_string(&bufp, f->se_str);
 345                         break;
 346                 default:
 347                         data->values[i] = f->val;
 348                 }
 349         }
 350         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) data->mask[i] = krule->mask[i];
 351
 352         return data;
 353 }
 354
 355 /* Compare two rules in kernel format.  Considered success if rules
 356  * don't match. */
 357 static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
 358 {
 359         int i;
 360
 361         if (a->flags != b->flags ||
 362             a->listnr != b->listnr ||
 363             a->action != b->action ||
 364             a->field_count != b->field_count)
 365                 return 1;
 366
 367         for (i = 0; i < a->field_count; i++) {
 368                 if (a->fields[i].type != b->fields[i].type ||
 369                     a->fields[i].op != b->fields[i].op)
 370                         return 1;
 371
 372                 switch(a->fields[i].type) {
 373                 case AUDIT_SE_USER:
 374                 case AUDIT_SE_ROLE:
 375                 case AUDIT_SE_TYPE:
 376                 case AUDIT_SE_SEN:
 377                 case AUDIT_SE_CLR:
 378                         if (strcmp(a->fields[i].se_str, b->fields[i].se_str))
 379                                 return 1;
 380                         break;
 381                 default:
 382                         if (a->fields[i].val != b->fields[i].val)
 383                                 return 1;
 384                 }
 385         }
 386
 387         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
 388                 if (a->mask[i] != b->mask[i])
 389                         return 1;
 390
 391         return 0;
 392 }
 393
 394 /* Duplicate selinux field information.  The se_rule is opaque, so must be
 395  * re-initialized. */
 396 static inline int audit_dupe_selinux_field(struct audit_field *df,
 397                                            struct audit_field *sf)
 398 {
 399         int ret = 0;
 400         char *se_str;
 401
 402         /* our own copy of se_str */
 403         se_str = kstrdup(sf->se_str, GFP_KERNEL);
 404         if (unlikely(IS_ERR(se_str)))
 405             return -ENOMEM;
 406         df->se_str = se_str;
 407
 408         /* our own (refreshed) copy of se_rule */
 409         ret = selinux_audit_rule_init(df->type, df->op, df->se_str,
 410                                       &df->se_rule);
 411         /* Keep currently invalid fields around in case they
 412          * become valid after a policy reload. */
 413         if (ret == -EINVAL) {
 414                 printk(KERN_WARNING "audit rule for selinux \'%s\' is "
 415                        "invalid\n", df->se_str);
 416                 ret = 0;
 417         }
 418
 419         return ret;
 420 }
 421
 422 /* Duplicate an audit rule.  This will be a deep copy with the exception
 423  * of the watch - that pointer is carried over.  The selinux specific fields
 424  * will be updated in the copy.  The point is to be able to replace the old
 425  * rule with the new rule in the filterlist, then free the old rule. */
 426 static struct audit_entry *audit_dupe_rule(struct audit_krule *old)
 427 {
 428         u32 fcount = old->field_count;
 429         struct audit_entry *entry;
 430         struct audit_krule *new;
 431         int i, err = 0;
 432
 433         entry = audit_init_entry(fcount);
 434         if (unlikely(!entry))
 435                 return ERR_PTR(-ENOMEM);
 436
 437         new = &entry->rule;
 438         new->vers_ops = old->vers_ops;
 439         new->flags = old->flags;
 440         new->listnr = old->listnr;
 441         new->action = old->action;
 442         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
 443                 new->mask[i] = old->mask[i];
 444         new->buflen = old->buflen;
 445         new->field_count = old->field_count;
 446         memcpy(new->fields, old->fields, sizeof(struct audit_field) * fcount);
 447
 448         /* deep copy this information, updating the se_rule fields, because
 449          * the originals will all be freed when the old rule is freed. */
 450         for (i = 0; i < fcount; i++) {
 451                 switch (new->fields[i].type) {
 452                 case AUDIT_SE_USER:
 453                 case AUDIT_SE_ROLE:
 454                 case AUDIT_SE_TYPE:
 455                 case AUDIT_SE_SEN:
 456                 case AUDIT_SE_CLR:
 457                         err = audit_dupe_selinux_field(&new->fields[i],
 458                                                        &old->fields[i]);
 459                 }
 460                 if (err) {
 461                         audit_free_rule(entry);
 462                         return ERR_PTR(err);
 463                 }
 464         }
 465
 466         return entry;
 467 }
 468
 469 /* Add rule to given filterlist if not a duplicate.  Protected by
 470  * audit_netlink_mutex. */
 471 static inline int audit_add_rule(struct audit_entry *entry,
 472                                   struct list_head *list)
 473 {
 474         struct audit_entry *e;
 475
 476         /* Do not use the _rcu iterator here, since this is the only
 477          * addition routine. */
 478         list_for_each_entry(e, list, list) {
 479                 if (!audit_compare_rule(&entry->rule, &e->rule))
 480                         return -EEXIST;
 481         }
 482
 483         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
 484                 list_add_rcu(&entry->list, list);
 485         } else {
 486                 list_add_tail_rcu(&entry->list, list);
 487         }
 488
 489         return 0;
 490 }
 491
 492 /* Remove an existing rule from filterlist.  Protected by
 493  * audit_netlink_mutex. */
 494 static inline int audit_del_rule(struct audit_entry *entry,
 495                                  struct list_head *list)
 496 {
 497         struct audit_entry  *e;
 498
 499         /* Do not use the _rcu iterator here, since this is the only
 500          * deletion routine. */
 501         list_for_each_entry(e, list, list) {
 502                 if (!audit_compare_rule(&entry->rule, &e->rule)) {
 503                         list_del_rcu(&e->list);
 504                         call_rcu(&e->rcu, audit_free_rule_rcu);
 505                         return 0;
 506                 }
 507         }
 508         return -ENOENT;         /* No matching rule */
 509 }
 510
 511 /* List rules using struct audit_rule.  Exists for backward
 512  * compatibility with userspace. */
 513 static int audit_list(void *_dest)
 514 {
 515         int pid, seq;
 516         int *dest = _dest;
 517         struct audit_entry *entry;
 518         int i;
 519
 520         pid = dest[0];
 521         seq = dest[1];
 522         kfree(dest);
 523
 524         mutex_lock(&audit_netlink_mutex);
 525
 526         /* The *_rcu iterators not needed here because we are
 527            always called with audit_netlink_mutex held. */
 528         for (i=0; i<AUDIT_NR_FILTERS; i++) {
 529                 list_for_each_entry(entry, &audit_filter_list[i], list) {
 530                         struct audit_rule *rule;
 531
 532                         rule = audit_krule_to_rule(&entry->rule);
 533                         if (unlikely(!rule))
 534                                 break;
 535                         audit_send_reply(pid, seq, AUDIT_LIST, 0, 1,
 536                                          rule, sizeof(*rule));
 537                         kfree(rule);
 538                 }
 539         }
 540         audit_send_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
 541
 542         mutex_unlock(&audit_netlink_mutex);
 543         return 0;
 544 }
 545
 546 /* List rules using struct audit_rule_data. */
 547 static int audit_list_rules(void *_dest)
 548 {
 549         int pid, seq;
 550         int *dest = _dest;
 551         struct audit_entry *e;
 552         int i;
 553
 554         pid = dest[0];
 555         seq = dest[1];
 556         kfree(dest);
 557
 558         mutex_lock(&audit_netlink_mutex);
 559
 560         /* The *_rcu iterators not needed here because we are
 561            always called with audit_netlink_mutex held. */
 562         for (i=0; i<AUDIT_NR_FILTERS; i++) {
 563                 list_for_each_entry(e, &audit_filter_list[i], list) {
 564                         struct audit_rule_data *data;
 565
 566                         data = audit_krule_to_data(&e->rule);
 567                         if (unlikely(!data))
 568                                 break;
 569                         audit_send_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
 570                                          data, sizeof(*data));
 571                         kfree(data);
 572                 }
 573         }
 574         audit_send_reply(pid, seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
 575
 576         mutex_unlock(&audit_netlink_mutex);
 577         return 0;
 578 }
 579
 580 /**
 581  * audit_receive_filter - apply all rules to the specified message type
 582  * @type: audit message type
 583  * @pid: target pid for netlink audit messages
 584  * @uid: target uid for netlink audit messages
 585  * @seq: netlink audit message sequence (serial) number
 586  * @data: payload data
 587  * @datasz: size of payload data
 588  * @loginuid: loginuid of sender
 589  * @sid: SE Linux Security ID of sender
 590  */
 591 int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
 592                          size_t datasz, uid_t loginuid, u32 sid)
 593 {
 594         struct task_struct *tsk;
 595         int *dest;
 596         int err = 0;
 597         struct audit_entry *entry;
 598
 599         switch (type) {
 600         case AUDIT_LIST:
 601         case AUDIT_LIST_RULES:
 602                 /* We can't just spew out the rules here because we might fill
 603                  * the available socket buffer space and deadlock waiting for
 604                  * auditctl to read from it... which isn't ever going to
 605                  * happen if we're actually running in the context of auditctl
 606                  * trying to _send_ the stuff */
 607
 608                 dest = kmalloc(2 * sizeof(int), GFP_KERNEL);
 609                 if (!dest)
 610                         return -ENOMEM;
 611                 dest[0] = pid;
 612                 dest[1] = seq;
 613
 614                 if (type == AUDIT_LIST)
 615                         tsk = kthread_run(audit_list, dest, "audit_list");
 616                 else
 617                         tsk = kthread_run(audit_list_rules, dest,
 618                                           "audit_list_rules");
 619                 if (IS_ERR(tsk)) {
 620                         kfree(dest);
 621                         err = PTR_ERR(tsk);
 622                 }
 623                 break;
 624         case AUDIT_ADD:
 625         case AUDIT_ADD_RULE:
 626                 if (type == AUDIT_ADD)
 627                         entry = audit_rule_to_entry(data);
 628                 else
 629                         entry = audit_data_to_entry(data, datasz);
 630                 if (IS_ERR(entry))
 631                         return PTR_ERR(entry);
 632
 633                 err = audit_add_rule(entry,
 634                                      &audit_filter_list[entry->rule.listnr]);
 635                 if (sid) {
 636                         char *ctx = NULL;
 637                         u32 len;
 638                         if (selinux_ctxid_to_string(sid, &ctx, &len)) {
 639                                 /* Maybe call audit_panic? */
 640                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 641                                  "auid=%u ssid=%u add rule to list=%d res=%d",
 642                                  loginuid, sid, entry->rule.listnr, !err);
 643                         } else
 644                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 645                                  "auid=%u subj=%s add rule to list=%d res=%d",
 646                                  loginuid, ctx, entry->rule.listnr, !err);
 647                         kfree(ctx);
 648                 } else
 649                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 650                                 "auid=%u add rule to list=%d res=%d",
 651                                 loginuid, entry->rule.listnr, !err);
 652
 653                 if (err)
 654                         audit_free_rule(entry);
 655                 break;
 656         case AUDIT_DEL:
 657         case AUDIT_DEL_RULE:
 658                 if (type == AUDIT_DEL)
 659                         entry = audit_rule_to_entry(data);
 660                 else
 661                         entry = audit_data_to_entry(data, datasz);
 662                 if (IS_ERR(entry))
 663                         return PTR_ERR(entry);
 664
 665                 err = audit_del_rule(entry,
 666                                      &audit_filter_list[entry->rule.listnr]);
 667
 668                 if (sid) {
 669                         char *ctx = NULL;
 670                         u32 len;
 671                         if (selinux_ctxid_to_string(sid, &ctx, &len)) {
 672                                 /* Maybe call audit_panic? */
 673                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 674                                         "auid=%u ssid=%u remove rule from list=%d res=%d",
 675                                          loginuid, sid, entry->rule.listnr, !err);
 676                         } else
 677                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 678                                         "auid=%u subj=%s remove rule from list=%d res=%d",
 679                                          loginuid, ctx, entry->rule.listnr, !err);
 680                         kfree(ctx);
 681                 } else
 682                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 683                                 "auid=%u remove rule from list=%d res=%d",
 684                                 loginuid, entry->rule.listnr, !err);
 685
 686                 audit_free_rule(entry);
 687                 break;
 688         default:
 689                 return -EINVAL;
 690         }
 691
 692         return err;
 693 }
 694
 695 int audit_comparator(const u32 left, const u32 op, const u32 right)
 696 {
 697         switch (op) {
 698         case AUDIT_EQUAL:
 699                 return (left == right);
 700         case AUDIT_NOT_EQUAL:
 701                 return (left != right);
 702         case AUDIT_LESS_THAN:
 703                 return (left < right);
 704         case AUDIT_LESS_THAN_OR_EQUAL:
 705                 return (left <= right);
 706         case AUDIT_GREATER_THAN:
 707                 return (left > right);
 708         case AUDIT_GREATER_THAN_OR_EQUAL:
 709                 return (left >= right);
 710         }
 711         BUG();
 712         return 0;
 713 }
 714
 715
 716
 717 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
 718                                    struct audit_krule *rule,
 719                                    enum audit_state *state)
 720 {
 721         int i;
 722
 723         for (i = 0; i < rule->field_count; i++) {
 724                 struct audit_field *f = &rule->fields[i];
 725                 int result = 0;
 726
 727                 switch (f->type) {
 728                 case AUDIT_PID:
 729                         result = audit_comparator(cb->creds.pid, f->op, f->val);
 730                         break;
 731                 case AUDIT_UID:
 732                         result = audit_comparator(cb->creds.uid, f->op, f->val);
 733                         break;
 734                 case AUDIT_GID:
 735                         result = audit_comparator(cb->creds.gid, f->op, f->val);
 736                         break;
 737                 case AUDIT_LOGINUID:
 738                         result = audit_comparator(cb->loginuid, f->op, f->val);
 739                         break;
 740                 }
 741
 742                 if (!result)
 743                         return 0;
 744         }
 745         switch (rule->action) {
 746         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
 747         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
 748         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
 749         }
 750         return 1;
 751 }
 752
 753 int audit_filter_user(struct netlink_skb_parms *cb, int type)
 754 {
 755         struct audit_entry *e;
 756         enum audit_state   state;
 757         int ret = 1;
 758
 759         rcu_read_lock();
 760         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_USER], list) {
 761                 if (audit_filter_user_rules(cb, &e->rule, &state)) {
 762                         if (state == AUDIT_DISABLED)
 763                                 ret = 0;
 764                         break;
 765                 }
 766         }
 767         rcu_read_unlock();
 768
 769         return ret; /* Audit by default */
 770 }
 771
 772 int audit_filter_type(int type)
 773 {
 774         struct audit_entry *e;
 775         int result = 0;
 776
 777         rcu_read_lock();
 778         if (list_empty(&audit_filter_list[AUDIT_FILTER_TYPE]))
 779                 goto unlock_and_return;
 780
 781         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TYPE],
 782                                 list) {
 783                 int i;
 784                 for (i = 0; i < e->rule.field_count; i++) {
 785                         struct audit_field *f = &e->rule.fields[i];
 786                         if (f->type == AUDIT_MSGTYPE) {
 787                                 result = audit_comparator(type, f->op, f->val);
 788                                 if (!result)
 789                                         break;
 790                         }
 791                 }
 792                 if (result)
 793                         goto unlock_and_return;
 794         }
 795 unlock_and_return:
 796         rcu_read_unlock();
 797         return result;
 798 }
 799
 800 /* Check to see if the rule contains any selinux fields.  Returns 1 if there
 801    are selinux fields specified in the rule, 0 otherwise. */
 802 static inline int audit_rule_has_selinux(struct audit_krule *rule)
 803 {
 804         int i;
 805
 806         for (i = 0; i < rule->field_count; i++) {
 807                 struct audit_field *f = &rule->fields[i];
 808                 switch (f->type) {
 809                 case AUDIT_SE_USER:
 810                 case AUDIT_SE_ROLE:
 811                 case AUDIT_SE_TYPE:
 812                 case AUDIT_SE_SEN:
 813                 case AUDIT_SE_CLR:
 814                         return 1;
 815                 }
 816         }
 817
 818         return 0;
 819 }
 820
 821 /* This function will re-initialize the se_rule field of all applicable rules.
 822  * It will traverse the filter lists serarching for rules that contain selinux
 823  * specific filter fields.  When such a rule is found, it is copied, the
 824  * selinux field is re-initialized, and the old rule is replaced with the
 825  * updated rule. */
 826 int selinux_audit_rule_update(void)
 827 {
 828         struct audit_entry *entry, *n, *nentry;
 829         int i, err = 0;
 830
 831         /* audit_netlink_mutex synchronizes the writers */
 832         mutex_lock(&audit_netlink_mutex);
 833
 834         for (i = 0; i < AUDIT_NR_FILTERS; i++) {
 835                 list_for_each_entry_safe(entry, n, &audit_filter_list[i], list) {
 836                         if (!audit_rule_has_selinux(&entry->rule))
 837                                 continue;
 838
 839                         nentry = audit_dupe_rule(&entry->rule);
 840                         if (unlikely(IS_ERR(nentry))) {
 841                                 /* save the first error encountered for the
 842                                  * return value */
 843                                 if (!err)
 844                                         err = PTR_ERR(nentry);
 845                                 audit_panic("error updating selinux filters");
 846                                 list_del_rcu(&entry->list);
 847                         } else {
 848                                 list_replace_rcu(&entry->list, &nentry->list);
 849                         }
 850                         call_rcu(&entry->rcu, audit_free_rule_rcu);
 851                 }
 852         }
 853
 854         mutex_unlock(&audit_netlink_mutex);
 855
 856         return err;
 857 }