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 void audit_list(int pid, int seq, struct sk_buff_head *q)
 514 {
 515         struct sk_buff *skb;
 516         struct audit_entry *entry;
 517         int i;
 518
 519         /* The *_rcu iterators not needed here because we are
 520            always called with audit_netlink_mutex held. */
 521         for (i=0; i<AUDIT_NR_FILTERS; i++) {
 522                 list_for_each_entry(entry, &audit_filter_list[i], list) {
 523                         struct audit_rule *rule;
 524
 525                         rule = audit_krule_to_rule(&entry->rule);
 526                         if (unlikely(!rule))
 527                                 break;
 528                         skb = audit_make_reply(pid, seq, AUDIT_LIST, 0, 1,
 529                                          rule, sizeof(*rule));
 530                         if (skb)
 531                                 skb_queue_tail(q, skb);
 532                         kfree(rule);
 533                 }
 534         }
 535         skb = audit_make_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
 536         if (skb)
 537                 skb_queue_tail(q, skb);
 538 }
 539
 540 /* List rules using struct audit_rule_data. */
 541 static void audit_list_rules(int pid, int seq, struct sk_buff_head *q)
 542 {
 543         struct sk_buff *skb;
 544         struct audit_entry *e;
 545         int i;
 546
 547         /* The *_rcu iterators not needed here because we are
 548            always called with audit_netlink_mutex held. */
 549         for (i=0; i<AUDIT_NR_FILTERS; i++) {
 550                 list_for_each_entry(e, &audit_filter_list[i], list) {
 551                         struct audit_rule_data *data;
 552
 553                         data = audit_krule_to_data(&e->rule);
 554                         if (unlikely(!data))
 555                                 break;
 556                         skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
 557                                          data, sizeof(*data));
 558                         if (skb)
 559                                 skb_queue_tail(q, skb);
 560                         kfree(data);
 561                 }
 562         }
 563         skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
 564         if (skb)
 565                 skb_queue_tail(q, skb);
 566 }
 567
 568 /**
 569  * audit_receive_filter - apply all rules to the specified message type
 570  * @type: audit message type
 571  * @pid: target pid for netlink audit messages
 572  * @uid: target uid for netlink audit messages
 573  * @seq: netlink audit message sequence (serial) number
 574  * @data: payload data
 575  * @datasz: size of payload data
 576  * @loginuid: loginuid of sender
 577  * @sid: SE Linux Security ID of sender
 578  */
 579 int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
 580                          size_t datasz, uid_t loginuid, u32 sid)
 581 {
 582         struct task_struct *tsk;
 583         struct audit_netlink_list *dest;
 584         int err = 0;
 585         struct audit_entry *entry;
 586
 587         switch (type) {
 588         case AUDIT_LIST:
 589         case AUDIT_LIST_RULES:
 590                 /* We can't just spew out the rules here because we might fill
 591                  * the available socket buffer space and deadlock waiting for
 592                  * auditctl to read from it... which isn't ever going to
 593                  * happen if we're actually running in the context of auditctl
 594                  * trying to _send_ the stuff */
 595
 596                 dest = kmalloc(sizeof(struct audit_netlink_list), GFP_KERNEL);
 597                 if (!dest)
 598                         return -ENOMEM;
 599                 dest->pid = pid;
 600                 skb_queue_head_init(&dest->q);
 601
 602                 if (type == AUDIT_LIST)
 603                         audit_list(pid, seq, &dest->q);
 604                 else
 605                         audit_list_rules(pid, seq, &dest->q);
 606
 607                 tsk = kthread_run(audit_send_list, dest, "audit_send_list");
 608                 if (IS_ERR(tsk)) {
 609                         skb_queue_purge(&dest->q);
 610                         kfree(dest);
 611                         err = PTR_ERR(tsk);
 612                 }
 613                 break;
 614         case AUDIT_ADD:
 615         case AUDIT_ADD_RULE:
 616                 if (type == AUDIT_ADD)
 617                         entry = audit_rule_to_entry(data);
 618                 else
 619                         entry = audit_data_to_entry(data, datasz);
 620                 if (IS_ERR(entry))
 621                         return PTR_ERR(entry);
 622
 623                 err = audit_add_rule(entry,
 624                                      &audit_filter_list[entry->rule.listnr]);
 625                 if (sid) {
 626                         char *ctx = NULL;
 627                         u32 len;
 628                         if (selinux_ctxid_to_string(sid, &ctx, &len)) {
 629                                 /* Maybe call audit_panic? */
 630                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 631                                  "auid=%u ssid=%u add rule to list=%d res=%d",
 632                                  loginuid, sid, entry->rule.listnr, !err);
 633                         } else
 634                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 635                                  "auid=%u subj=%s add rule to list=%d res=%d",
 636                                  loginuid, ctx, entry->rule.listnr, !err);
 637                         kfree(ctx);
 638                 } else
 639                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 640                                 "auid=%u add rule to list=%d res=%d",
 641                                 loginuid, entry->rule.listnr, !err);
 642
 643                 if (err)
 644                         audit_free_rule(entry);
 645                 break;
 646         case AUDIT_DEL:
 647         case AUDIT_DEL_RULE:
 648                 if (type == AUDIT_DEL)
 649                         entry = audit_rule_to_entry(data);
 650                 else
 651                         entry = audit_data_to_entry(data, datasz);
 652                 if (IS_ERR(entry))
 653                         return PTR_ERR(entry);
 654
 655                 err = audit_del_rule(entry,
 656                                      &audit_filter_list[entry->rule.listnr]);
 657
 658                 if (sid) {
 659                         char *ctx = NULL;
 660                         u32 len;
 661                         if (selinux_ctxid_to_string(sid, &ctx, &len)) {
 662                                 /* Maybe call audit_panic? */
 663                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 664                                         "auid=%u ssid=%u remove rule from list=%d res=%d",
 665                                          loginuid, sid, entry->rule.listnr, !err);
 666                         } else
 667                                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 668                                         "auid=%u subj=%s remove rule from list=%d res=%d",
 669                                          loginuid, ctx, entry->rule.listnr, !err);
 670                         kfree(ctx);
 671                 } else
 672                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
 673                                 "auid=%u remove rule from list=%d res=%d",
 674                                 loginuid, entry->rule.listnr, !err);
 675
 676                 audit_free_rule(entry);
 677                 break;
 678         default:
 679                 return -EINVAL;
 680         }
 681
 682         return err;
 683 }
 684
 685 int audit_comparator(const u32 left, const u32 op, const u32 right)
 686 {
 687         switch (op) {
 688         case AUDIT_EQUAL:
 689                 return (left == right);
 690         case AUDIT_NOT_EQUAL:
 691                 return (left != right);
 692         case AUDIT_LESS_THAN:
 693                 return (left < right);
 694         case AUDIT_LESS_THAN_OR_EQUAL:
 695                 return (left <= right);
 696         case AUDIT_GREATER_THAN:
 697                 return (left > right);
 698         case AUDIT_GREATER_THAN_OR_EQUAL:
 699                 return (left >= right);
 700         }
 701         BUG();
 702         return 0;
 703 }
 704
 705
 706
 707 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
 708                                    struct audit_krule *rule,
 709                                    enum audit_state *state)
 710 {
 711         int i;
 712
 713         for (i = 0; i < rule->field_count; i++) {
 714                 struct audit_field *f = &rule->fields[i];
 715                 int result = 0;
 716
 717                 switch (f->type) {
 718                 case AUDIT_PID:
 719                         result = audit_comparator(cb->creds.pid, f->op, f->val);
 720                         break;
 721                 case AUDIT_UID:
 722                         result = audit_comparator(cb->creds.uid, f->op, f->val);
 723                         break;
 724                 case AUDIT_GID:
 725                         result = audit_comparator(cb->creds.gid, f->op, f->val);
 726                         break;
 727                 case AUDIT_LOGINUID:
 728                         result = audit_comparator(cb->loginuid, f->op, f->val);
 729                         break;
 730                 }
 731
 732                 if (!result)
 733                         return 0;
 734         }
 735         switch (rule->action) {
 736         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
 737         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
 738         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
 739         }
 740         return 1;
 741 }
 742
 743 int audit_filter_user(struct netlink_skb_parms *cb, int type)
 744 {
 745         struct audit_entry *e;
 746         enum audit_state   state;
 747         int ret = 1;
 748
 749         rcu_read_lock();
 750         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_USER], list) {
 751                 if (audit_filter_user_rules(cb, &e->rule, &state)) {
 752                         if (state == AUDIT_DISABLED)
 753                                 ret = 0;
 754                         break;
 755                 }
 756         }
 757         rcu_read_unlock();
 758
 759         return ret; /* Audit by default */
 760 }
 761
 762 int audit_filter_type(int type)
 763 {
 764         struct audit_entry *e;
 765         int result = 0;
 766
 767         rcu_read_lock();
 768         if (list_empty(&audit_filter_list[AUDIT_FILTER_TYPE]))
 769                 goto unlock_and_return;
 770
 771         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TYPE],
 772                                 list) {
 773                 int i;
 774                 for (i = 0; i < e->rule.field_count; i++) {
 775                         struct audit_field *f = &e->rule.fields[i];
 776                         if (f->type == AUDIT_MSGTYPE) {
 777                                 result = audit_comparator(type, f->op, f->val);
 778                                 if (!result)
 779                                         break;
 780                         }
 781                 }
 782                 if (result)
 783                         goto unlock_and_return;
 784         }
 785 unlock_and_return:
 786         rcu_read_unlock();
 787         return result;
 788 }
 789
 790 /* Check to see if the rule contains any selinux fields.  Returns 1 if there
 791    are selinux fields specified in the rule, 0 otherwise. */
 792 static inline int audit_rule_has_selinux(struct audit_krule *rule)
 793 {
 794         int i;
 795
 796         for (i = 0; i < rule->field_count; i++) {
 797                 struct audit_field *f = &rule->fields[i];
 798                 switch (f->type) {
 799                 case AUDIT_SE_USER:
 800                 case AUDIT_SE_ROLE:
 801                 case AUDIT_SE_TYPE:
 802                 case AUDIT_SE_SEN:
 803                 case AUDIT_SE_CLR:
 804                         return 1;
 805                 }
 806         }
 807
 808         return 0;
 809 }
 810
 811 /* This function will re-initialize the se_rule field of all applicable rules.
 812  * It will traverse the filter lists serarching for rules that contain selinux
 813  * specific filter fields.  When such a rule is found, it is copied, the
 814  * selinux field is re-initialized, and the old rule is replaced with the
 815  * updated rule. */
 816 int selinux_audit_rule_update(void)
 817 {
 818         struct audit_entry *entry, *n, *nentry;
 819         int i, err = 0;
 820
 821         /* audit_netlink_mutex synchronizes the writers */
 822         mutex_lock(&audit_netlink_mutex);
 823
 824         for (i = 0; i < AUDIT_NR_FILTERS; i++) {
 825                 list_for_each_entry_safe(entry, n, &audit_filter_list[i], list) {
 826                         if (!audit_rule_has_selinux(&entry->rule))
 827                                 continue;
 828
 829                         nentry = audit_dupe_rule(&entry->rule);
 830                         if (unlikely(IS_ERR(nentry))) {
 831                                 /* save the first error encountered for the
 832                                  * return value */
 833                                 if (!err)
 834                                         err = PTR_ERR(nentry);
 835                                 audit_panic("error updating selinux filters");
 836                                 list_del_rcu(&entry->list);
 837                         } else {
 838                                 list_replace_rcu(&entry->list, &nentry->list);
 839                         }
 840                         call_rcu(&entry->rcu, audit_free_rule_rcu);
 841                 }
 842         }
 843
 844         mutex_unlock(&audit_netlink_mutex);
 845
 846         return err;
 847 }