LCOV - code coverage report
Current view: top level - kernel - auditfilter.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 18 683 2.6 %
Date: 2022-04-01 13:59:58 Functions: 2 28 7.1 %
Branches: 7 418 1.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* auditfilter.c -- filtering of audit events
       3                 :            :  *
       4                 :            :  * Copyright 2003-2004 Red Hat, Inc.
       5                 :            :  * Copyright 2005 Hewlett-Packard Development Company, L.P.
       6                 :            :  * Copyright 2005 IBM Corporation
       7                 :            :  */
       8                 :            : 
       9                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      10                 :            : 
      11                 :            : #include <linux/kernel.h>
      12                 :            : #include <linux/audit.h>
      13                 :            : #include <linux/kthread.h>
      14                 :            : #include <linux/mutex.h>
      15                 :            : #include <linux/fs.h>
      16                 :            : #include <linux/namei.h>
      17                 :            : #include <linux/netlink.h>
      18                 :            : #include <linux/sched.h>
      19                 :            : #include <linux/slab.h>
      20                 :            : #include <linux/security.h>
      21                 :            : #include <net/net_namespace.h>
      22                 :            : #include <net/sock.h>
      23                 :            : #include "audit.h"
      24                 :            : 
      25                 :            : /*
      26                 :            :  * Locking model:
      27                 :            :  *
      28                 :            :  * audit_filter_mutex:
      29                 :            :  *              Synchronizes writes and blocking reads of audit's filterlist
      30                 :            :  *              data.  Rcu is used to traverse the filterlist and access
      31                 :            :  *              contents of structs audit_entry, audit_watch and opaque
      32                 :            :  *              LSM rules during filtering.  If modified, these structures
      33                 :            :  *              must be copied and replace their counterparts in the filterlist.
      34                 :            :  *              An audit_parent struct is not accessed during filtering, so may
      35                 :            :  *              be written directly provided audit_filter_mutex is held.
      36                 :            :  */
      37                 :            : 
      38                 :            : /* Audit filter lists, defined in <linux/audit.h> */
      39                 :            : struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
      40                 :            :         LIST_HEAD_INIT(audit_filter_list[0]),
      41                 :            :         LIST_HEAD_INIT(audit_filter_list[1]),
      42                 :            :         LIST_HEAD_INIT(audit_filter_list[2]),
      43                 :            :         LIST_HEAD_INIT(audit_filter_list[3]),
      44                 :            :         LIST_HEAD_INIT(audit_filter_list[4]),
      45                 :            :         LIST_HEAD_INIT(audit_filter_list[5]),
      46                 :            :         LIST_HEAD_INIT(audit_filter_list[6]),
      47                 :            : #if AUDIT_NR_FILTERS != 7
      48                 :            : #error Fix audit_filter_list initialiser
      49                 :            : #endif
      50                 :            : };
      51                 :            : static struct list_head audit_rules_list[AUDIT_NR_FILTERS] = {
      52                 :            :         LIST_HEAD_INIT(audit_rules_list[0]),
      53                 :            :         LIST_HEAD_INIT(audit_rules_list[1]),
      54                 :            :         LIST_HEAD_INIT(audit_rules_list[2]),
      55                 :            :         LIST_HEAD_INIT(audit_rules_list[3]),
      56                 :            :         LIST_HEAD_INIT(audit_rules_list[4]),
      57                 :            :         LIST_HEAD_INIT(audit_rules_list[5]),
      58                 :            :         LIST_HEAD_INIT(audit_rules_list[6]),
      59                 :            : };
      60                 :            : 
      61                 :            : DEFINE_MUTEX(audit_filter_mutex);
      62                 :            : 
      63                 :          0 : static void audit_free_lsm_field(struct audit_field *f)
      64                 :            : {
      65         [ #  # ]:          0 :         switch (f->type) {
      66                 :          0 :         case AUDIT_SUBJ_USER:
      67                 :            :         case AUDIT_SUBJ_ROLE:
      68                 :            :         case AUDIT_SUBJ_TYPE:
      69                 :            :         case AUDIT_SUBJ_SEN:
      70                 :            :         case AUDIT_SUBJ_CLR:
      71                 :            :         case AUDIT_OBJ_USER:
      72                 :            :         case AUDIT_OBJ_ROLE:
      73                 :            :         case AUDIT_OBJ_TYPE:
      74                 :            :         case AUDIT_OBJ_LEV_LOW:
      75                 :            :         case AUDIT_OBJ_LEV_HIGH:
      76                 :          0 :                 kfree(f->lsm_str);
      77                 :          0 :                 security_audit_rule_free(f->lsm_rule);
      78                 :            :         }
      79                 :          0 : }
      80                 :            : 
      81                 :          0 : static inline void audit_free_rule(struct audit_entry *e)
      82                 :            : {
      83                 :          0 :         int i;
      84                 :          0 :         struct audit_krule *erule = &e->rule;
      85                 :            : 
      86                 :            :         /* some rules don't have associated watches */
      87         [ #  # ]:          0 :         if (erule->watch)
      88                 :          0 :                 audit_put_watch(erule->watch);
      89         [ #  # ]:          0 :         if (erule->fields)
      90         [ #  # ]:          0 :                 for (i = 0; i < erule->field_count; i++)
      91                 :          0 :                         audit_free_lsm_field(&erule->fields[i]);
      92                 :          0 :         kfree(erule->fields);
      93                 :          0 :         kfree(erule->filterkey);
      94                 :          0 :         kfree(e);
      95                 :          0 : }
      96                 :            : 
      97                 :          0 : void audit_free_rule_rcu(struct rcu_head *head)
      98                 :            : {
      99                 :          0 :         struct audit_entry *e = container_of(head, struct audit_entry, rcu);
     100                 :          0 :         audit_free_rule(e);
     101                 :          0 : }
     102                 :            : 
     103                 :            : /* Initialize an audit filterlist entry. */
     104                 :          0 : static inline struct audit_entry *audit_init_entry(u32 field_count)
     105                 :            : {
     106                 :          0 :         struct audit_entry *entry;
     107                 :          0 :         struct audit_field *fields;
     108                 :            : 
     109                 :          0 :         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
     110         [ #  # ]:          0 :         if (unlikely(!entry))
     111                 :            :                 return NULL;
     112                 :            : 
     113                 :          0 :         fields = kcalloc(field_count, sizeof(*fields), GFP_KERNEL);
     114         [ #  # ]:          0 :         if (unlikely(!fields)) {
     115                 :          0 :                 kfree(entry);
     116                 :          0 :                 return NULL;
     117                 :            :         }
     118                 :          0 :         entry->rule.fields = fields;
     119                 :            : 
     120                 :          0 :         return entry;
     121                 :            : }
     122                 :            : 
     123                 :            : /* Unpack a filter field's string representation from user-space
     124                 :            :  * buffer. */
     125                 :          0 : char *audit_unpack_string(void **bufp, size_t *remain, size_t len)
     126                 :            : {
     127                 :          0 :         char *str;
     128                 :            : 
     129   [ #  #  #  #  :          0 :         if (!*bufp || (len == 0) || (len > *remain))
                   #  # ]
     130                 :            :                 return ERR_PTR(-EINVAL);
     131                 :            : 
     132                 :            :         /* Of the currently implemented string fields, PATH_MAX
     133                 :            :          * defines the longest valid length.
     134                 :            :          */
     135         [ #  # ]:          0 :         if (len > PATH_MAX)
     136                 :            :                 return ERR_PTR(-ENAMETOOLONG);
     137                 :            : 
     138         [ #  # ]:          0 :         str = kmalloc(len + 1, GFP_KERNEL);
     139         [ #  # ]:          0 :         if (unlikely(!str))
     140                 :            :                 return ERR_PTR(-ENOMEM);
     141                 :            : 
     142                 :          0 :         memcpy(str, *bufp, len);
     143                 :          0 :         str[len] = 0;
     144                 :          0 :         *bufp += len;
     145                 :          0 :         *remain -= len;
     146                 :            : 
     147                 :          0 :         return str;
     148                 :            : }
     149                 :            : 
     150                 :            : /* Translate an inode field to kernel representation. */
     151                 :          0 : static inline int audit_to_inode(struct audit_krule *krule,
     152                 :            :                                  struct audit_field *f)
     153                 :            : {
     154                 :          0 :         if (krule->listnr != AUDIT_FILTER_EXIT ||
     155   [ #  #  #  #  :          0 :             krule->inode_f || krule->watch || krule->tree ||
                   #  # ]
     156         [ #  # ]:          0 :             (f->op != Audit_equal && f->op != Audit_not_equal))
     157                 :            :                 return -EINVAL;
     158                 :            : 
     159                 :          0 :         krule->inode_f = f;
     160                 :          0 :         return 0;
     161                 :            : }
     162                 :            : 
     163                 :            : static __u32 *classes[AUDIT_SYSCALL_CLASSES];
     164                 :            : 
     165                 :        780 : int __init audit_register_class(int class, unsigned *list)
     166                 :            : {
     167                 :        780 :         __u32 *p = kcalloc(AUDIT_BITMASK_SIZE, sizeof(__u32), GFP_KERNEL);
     168         [ +  - ]:        780 :         if (!p)
     169                 :            :                 return -ENOMEM;
     170         [ +  + ]:      11154 :         while (*list != ~0U) {
     171                 :      10374 :                 unsigned n = *list++;
     172         [ -  + ]:      10374 :                 if (n >= AUDIT_BITMASK_SIZE * 32 - AUDIT_SYSCALL_CLASSES) {
     173                 :          0 :                         kfree(p);
     174                 :          0 :                         return -EINVAL;
     175                 :            :                 }
     176                 :      10374 :                 p[AUDIT_WORD(n)] |= AUDIT_BIT(n);
     177                 :            :         }
     178   [ +  -  -  + ]:        780 :         if (class >= AUDIT_SYSCALL_CLASSES || classes[class]) {
     179                 :          0 :                 kfree(p);
     180                 :          0 :                 return -EINVAL;
     181                 :            :         }
     182                 :        780 :         classes[class] = p;
     183                 :        780 :         return 0;
     184                 :            : }
     185                 :            : 
     186                 :          0 : int audit_match_class(int class, unsigned syscall)
     187                 :            : {
     188         [ #  # ]:          0 :         if (unlikely(syscall >= AUDIT_BITMASK_SIZE * 32))
     189                 :            :                 return 0;
     190   [ #  #  #  # ]:          0 :         if (unlikely(class >= AUDIT_SYSCALL_CLASSES || !classes[class]))
     191                 :            :                 return 0;
     192                 :          0 :         return classes[class][AUDIT_WORD(syscall)] & AUDIT_BIT(syscall);
     193                 :            : }
     194                 :            : 
     195                 :            : #ifdef CONFIG_AUDITSYSCALL
     196                 :          0 : static inline int audit_match_class_bits(int class, u32 *mask)
     197                 :            : {
     198                 :          0 :         int i;
     199                 :            : 
     200         [ #  # ]:          0 :         if (classes[class]) {
     201   [ #  #  #  #  :          0 :                 for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
             #  #  #  # ]
     202   [ #  #  #  #  :          0 :                         if (mask[i] & classes[class][i])
             #  #  #  # ]
     203                 :            :                                 return 0;
     204                 :            :         }
     205                 :            :         return 1;
     206                 :            : }
     207                 :            : 
     208                 :          0 : static int audit_match_signal(struct audit_entry *entry)
     209                 :            : {
     210                 :          0 :         struct audit_field *arch = entry->rule.arch_f;
     211                 :            : 
     212         [ #  # ]:          0 :         if (!arch) {
     213                 :            :                 /* When arch is unspecified, we must check both masks on biarch
     214                 :            :                  * as syscall number alone is ambiguous. */
     215                 :          0 :                 return (audit_match_class_bits(AUDIT_CLASS_SIGNAL,
     216   [ #  #  #  # ]:          0 :                                                entry->rule.mask) &&
     217                 :            :                         audit_match_class_bits(AUDIT_CLASS_SIGNAL_32,
     218                 :            :                                                entry->rule.mask));
     219                 :            :         }
     220                 :            : 
     221      [ #  #  # ]:          0 :         switch(audit_classify_arch(arch->val)) {
     222                 :          0 :         case 0: /* native */
     223                 :          0 :                 return (audit_match_class_bits(AUDIT_CLASS_SIGNAL,
     224         [ #  # ]:          0 :                                                entry->rule.mask));
     225                 :          0 :         case 1: /* 32bit on biarch */
     226                 :          0 :                 return (audit_match_class_bits(AUDIT_CLASS_SIGNAL_32,
     227         [ #  # ]:          0 :                                                entry->rule.mask));
     228                 :            :         default:
     229                 :            :                 return 1;
     230                 :            :         }
     231                 :            : }
     232                 :            : #endif
     233                 :            : 
     234                 :            : /* Common user-space to kernel rule translation. */
     235                 :          0 : static inline struct audit_entry *audit_to_entry_common(struct audit_rule_data *rule)
     236                 :            : {
     237                 :          0 :         unsigned listnr;
     238                 :          0 :         struct audit_entry *entry;
     239                 :          0 :         int i, err;
     240                 :            : 
     241                 :          0 :         err = -EINVAL;
     242                 :          0 :         listnr = rule->flags & ~AUDIT_FILTER_PREPEND;
     243      [ #  #  # ]:          0 :         switch(listnr) {
     244                 :          0 :         default:
     245                 :          0 :                 goto exit_err;
     246                 :            : #ifdef CONFIG_AUDITSYSCALL
     247                 :          0 :         case AUDIT_FILTER_ENTRY:
     248                 :          0 :                 pr_err("AUDIT_FILTER_ENTRY is deprecated\n");
     249                 :          0 :                 goto exit_err;
     250                 :          0 :         case AUDIT_FILTER_EXIT:
     251                 :            :         case AUDIT_FILTER_TASK:
     252                 :            : #endif
     253                 :            :         case AUDIT_FILTER_USER:
     254                 :            :         case AUDIT_FILTER_EXCLUDE:
     255                 :            :         case AUDIT_FILTER_FS:
     256                 :          0 :                 ;
     257                 :            :         }
     258         [ #  # ]:          0 :         if (unlikely(rule->action == AUDIT_POSSIBLE)) {
     259                 :          0 :                 pr_err("AUDIT_POSSIBLE is deprecated\n");
     260                 :          0 :                 goto exit_err;
     261                 :            :         }
     262         [ #  # ]:          0 :         if (rule->action != AUDIT_NEVER && rule->action != AUDIT_ALWAYS)
     263                 :          0 :                 goto exit_err;
     264         [ #  # ]:          0 :         if (rule->field_count > AUDIT_MAX_FIELDS)
     265                 :          0 :                 goto exit_err;
     266                 :            : 
     267                 :          0 :         err = -ENOMEM;
     268                 :          0 :         entry = audit_init_entry(rule->field_count);
     269         [ #  # ]:          0 :         if (!entry)
     270                 :          0 :                 goto exit_err;
     271                 :            : 
     272                 :          0 :         entry->rule.flags = rule->flags & AUDIT_FILTER_PREPEND;
     273                 :          0 :         entry->rule.listnr = listnr;
     274                 :          0 :         entry->rule.action = rule->action;
     275                 :          0 :         entry->rule.field_count = rule->field_count;
     276                 :            : 
     277         [ #  # ]:          0 :         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
     278                 :          0 :                 entry->rule.mask[i] = rule->mask[i];
     279                 :            : 
     280         [ #  # ]:          0 :         for (i = 0; i < AUDIT_SYSCALL_CLASSES; i++) {
     281                 :          0 :                 int bit = AUDIT_BITMASK_SIZE * 32 - i - 1;
     282                 :          0 :                 __u32 *p = &entry->rule.mask[AUDIT_WORD(bit)];
     283                 :          0 :                 __u32 *class;
     284                 :            : 
     285         [ #  # ]:          0 :                 if (!(*p & AUDIT_BIT(bit)))
     286                 :          0 :                         continue;
     287                 :          0 :                 *p &= ~AUDIT_BIT(bit);
     288                 :          0 :                 class = classes[i];
     289         [ #  # ]:          0 :                 if (class) {
     290                 :            :                         int j;
     291         [ #  # ]:          0 :                         for (j = 0; j < AUDIT_BITMASK_SIZE; j++)
     292                 :          0 :                                 entry->rule.mask[j] |= class[j];
     293                 :            :                 }
     294                 :            :         }
     295                 :            : 
     296                 :            :         return entry;
     297                 :            : 
     298                 :          0 : exit_err:
     299                 :          0 :         return ERR_PTR(err);
     300                 :            : }
     301                 :            : 
     302                 :            : static u32 audit_ops[] =
     303                 :            : {
     304                 :            :         [Audit_equal] = AUDIT_EQUAL,
     305                 :            :         [Audit_not_equal] = AUDIT_NOT_EQUAL,
     306                 :            :         [Audit_bitmask] = AUDIT_BIT_MASK,
     307                 :            :         [Audit_bittest] = AUDIT_BIT_TEST,
     308                 :            :         [Audit_lt] = AUDIT_LESS_THAN,
     309                 :            :         [Audit_gt] = AUDIT_GREATER_THAN,
     310                 :            :         [Audit_le] = AUDIT_LESS_THAN_OR_EQUAL,
     311                 :            :         [Audit_ge] = AUDIT_GREATER_THAN_OR_EQUAL,
     312                 :            : };
     313                 :            : 
     314                 :          0 : static u32 audit_to_op(u32 op)
     315                 :            : {
     316                 :          0 :         u32 n;
     317   [ #  #  #  # ]:          0 :         for (n = Audit_equal; n < Audit_bad && audit_ops[n] != op; n++)
     318                 :          0 :                 ;
     319                 :          0 :         return n;
     320                 :            : }
     321                 :            : 
     322                 :            : /* check if an audit field is valid */
     323                 :            : static int audit_field_valid(struct audit_entry *entry, struct audit_field *f)
     324                 :            : {
     325                 :            :         switch (f->type) {
     326                 :            :         case AUDIT_MSGTYPE:
     327                 :            :                 if (entry->rule.listnr != AUDIT_FILTER_EXCLUDE &&
     328                 :            :                     entry->rule.listnr != AUDIT_FILTER_USER)
     329                 :            :                         return -EINVAL;
     330                 :            :                 break;
     331                 :            :         case AUDIT_FSTYPE:
     332                 :            :                 if (entry->rule.listnr != AUDIT_FILTER_FS)
     333                 :            :                         return -EINVAL;
     334                 :            :                 break;
     335                 :            :         }
     336                 :            : 
     337                 :            :         switch (entry->rule.listnr) {
     338                 :            :         case AUDIT_FILTER_FS:
     339                 :            :                 switch(f->type) {
     340                 :            :                 case AUDIT_FSTYPE:
     341                 :            :                 case AUDIT_FILTERKEY:
     342                 :            :                         break;
     343                 :            :                 default:
     344                 :            :                         return -EINVAL;
     345                 :            :                 }
     346                 :            :         }
     347                 :            : 
     348                 :            :         /* Check for valid field type and op */
     349                 :            :         switch (f->type) {
     350                 :            :         case AUDIT_ARG0:
     351                 :            :         case AUDIT_ARG1:
     352                 :            :         case AUDIT_ARG2:
     353                 :            :         case AUDIT_ARG3:
     354                 :            :         case AUDIT_PERS: /* <uapi/linux/personality.h> */
     355                 :            :         case AUDIT_DEVMINOR:
     356                 :            :                 /* all ops are valid */
     357                 :            :                 break;
     358                 :            :         case AUDIT_UID:
     359                 :            :         case AUDIT_EUID:
     360                 :            :         case AUDIT_SUID:
     361                 :            :         case AUDIT_FSUID:
     362                 :            :         case AUDIT_LOGINUID:
     363                 :            :         case AUDIT_OBJ_UID:
     364                 :            :         case AUDIT_GID:
     365                 :            :         case AUDIT_EGID:
     366                 :            :         case AUDIT_SGID:
     367                 :            :         case AUDIT_FSGID:
     368                 :            :         case AUDIT_OBJ_GID:
     369                 :            :         case AUDIT_PID:
     370                 :            :         case AUDIT_MSGTYPE:
     371                 :            :         case AUDIT_PPID:
     372                 :            :         case AUDIT_DEVMAJOR:
     373                 :            :         case AUDIT_EXIT:
     374                 :            :         case AUDIT_SUCCESS:
     375                 :            :         case AUDIT_INODE:
     376                 :            :         case AUDIT_SESSIONID:
     377                 :            :         case AUDIT_SUBJ_SEN:
     378                 :            :         case AUDIT_SUBJ_CLR:
     379                 :            :         case AUDIT_OBJ_LEV_LOW:
     380                 :            :         case AUDIT_OBJ_LEV_HIGH:
     381                 :            :         case AUDIT_SADDR_FAM:
     382                 :            :                 /* bit ops are only useful on syscall args */
     383                 :            :                 if (f->op == Audit_bitmask || f->op == Audit_bittest)
     384                 :            :                         return -EINVAL;
     385                 :            :                 break;
     386                 :            :         case AUDIT_SUBJ_USER:
     387                 :            :         case AUDIT_SUBJ_ROLE:
     388                 :            :         case AUDIT_SUBJ_TYPE:
     389                 :            :         case AUDIT_OBJ_USER:
     390                 :            :         case AUDIT_OBJ_ROLE:
     391                 :            :         case AUDIT_OBJ_TYPE:
     392                 :            :         case AUDIT_WATCH:
     393                 :            :         case AUDIT_DIR:
     394                 :            :         case AUDIT_FILTERKEY:
     395                 :            :         case AUDIT_LOGINUID_SET:
     396                 :            :         case AUDIT_ARCH:
     397                 :            :         case AUDIT_FSTYPE:
     398                 :            :         case AUDIT_PERM:
     399                 :            :         case AUDIT_FILETYPE:
     400                 :            :         case AUDIT_FIELD_COMPARE:
     401                 :            :         case AUDIT_EXE:
     402                 :            :                 /* only equal and not equal valid ops */
     403                 :            :                 if (f->op != Audit_not_equal && f->op != Audit_equal)
     404                 :            :                         return -EINVAL;
     405                 :            :                 break;
     406                 :            :         default:
     407                 :            :                 /* field not recognized */
     408                 :            :                 return -EINVAL;
     409                 :            :         }
     410                 :            : 
     411                 :            :         /* Check for select valid field values */
     412                 :            :         switch (f->type) {
     413                 :            :         case AUDIT_LOGINUID_SET:
     414                 :            :                 if ((f->val != 0) && (f->val != 1))
     415                 :            :                         return -EINVAL;
     416                 :            :                 break;
     417                 :            :         case AUDIT_PERM:
     418                 :            :                 if (f->val & ~15)
     419                 :            :                         return -EINVAL;
     420                 :            :                 break;
     421                 :            :         case AUDIT_FILETYPE:
     422                 :            :                 if (f->val & ~S_IFMT)
     423                 :            :                         return -EINVAL;
     424                 :            :                 break;
     425                 :            :         case AUDIT_FIELD_COMPARE:
     426                 :            :                 if (f->val > AUDIT_MAX_FIELD_COMPARE)
     427                 :            :                         return -EINVAL;
     428                 :            :                 break;
     429                 :            :         case AUDIT_SADDR_FAM:
     430                 :            :                 if (f->val >= AF_MAX)
     431                 :            :                         return -EINVAL;
     432                 :            :                 break;
     433                 :            :         default:
     434                 :            :                 break;
     435                 :            :         }
     436                 :            : 
     437                 :            :         return 0;
     438                 :            : }
     439                 :            : 
     440                 :            : /* Translate struct audit_rule_data to kernel's rule representation. */
     441                 :          0 : static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
     442                 :            :                                                size_t datasz)
     443                 :            : {
     444                 :          0 :         int err = 0;
     445                 :          0 :         struct audit_entry *entry;
     446                 :          0 :         void *bufp;
     447                 :          0 :         size_t remain = datasz - sizeof(struct audit_rule_data);
     448                 :          0 :         int i;
     449                 :          0 :         char *str;
     450                 :          0 :         struct audit_fsnotify_mark *audit_mark;
     451                 :            : 
     452                 :          0 :         entry = audit_to_entry_common(data);
     453         [ #  # ]:          0 :         if (IS_ERR(entry))
     454                 :          0 :                 goto exit_nofree;
     455                 :            : 
     456                 :          0 :         bufp = data->buf;
     457         [ #  # ]:          0 :         for (i = 0; i < data->field_count; i++) {
     458                 :          0 :                 struct audit_field *f = &entry->rule.fields[i];
     459                 :          0 :                 u32 f_val;
     460                 :            : 
     461                 :          0 :                 err = -EINVAL;
     462                 :            : 
     463                 :          0 :                 f->op = audit_to_op(data->fieldflags[i]);
     464         [ #  # ]:          0 :                 if (f->op == Audit_bad)
     465                 :          0 :                         goto exit_free;
     466                 :            : 
     467                 :          0 :                 f->type = data->fields[i];
     468                 :          0 :                 f_val = data->values[i];
     469                 :            : 
     470                 :            :                 /* Support legacy tests for a valid loginuid */
     471   [ #  #  #  # ]:          0 :                 if ((f->type == AUDIT_LOGINUID) && (f_val == AUDIT_UID_UNSET)) {
     472                 :          0 :                         f->type = AUDIT_LOGINUID_SET;
     473                 :          0 :                         f_val = 0;
     474                 :          0 :                         entry->rule.pflags |= AUDIT_LOGINUID_LEGACY;
     475                 :            :                 }
     476                 :            : 
     477                 :          0 :                 err = audit_field_valid(entry, f);
     478         [ #  # ]:          0 :                 if (err)
     479                 :          0 :                         goto exit_free;
     480                 :            : 
     481                 :          0 :                 err = -EINVAL;
     482   [ #  #  #  #  :          0 :                 switch (f->type) {
          #  #  #  #  #  
                      # ]
     483                 :            :                 case AUDIT_LOGINUID:
     484                 :            :                 case AUDIT_UID:
     485                 :            :                 case AUDIT_EUID:
     486                 :            :                 case AUDIT_SUID:
     487                 :            :                 case AUDIT_FSUID:
     488                 :            :                 case AUDIT_OBJ_UID:
     489         [ #  # ]:          0 :                         f->uid = make_kuid(current_user_ns(), f_val);
     490         [ #  # ]:          0 :                         if (!uid_valid(f->uid))
     491                 :          0 :                                 goto exit_free;
     492                 :            :                         break;
     493                 :            :                 case AUDIT_GID:
     494                 :            :                 case AUDIT_EGID:
     495                 :            :                 case AUDIT_SGID:
     496                 :            :                 case AUDIT_FSGID:
     497                 :            :                 case AUDIT_OBJ_GID:
     498         [ #  # ]:          0 :                         f->gid = make_kgid(current_user_ns(), f_val);
     499         [ #  # ]:          0 :                         if (!gid_valid(f->gid))
     500                 :          0 :                                 goto exit_free;
     501                 :            :                         break;
     502                 :          0 :                 case AUDIT_ARCH:
     503                 :          0 :                         f->val = f_val;
     504                 :          0 :                         entry->rule.arch_f = f;
     505                 :          0 :                         break;
     506                 :          0 :                 case AUDIT_SUBJ_USER:
     507                 :            :                 case AUDIT_SUBJ_ROLE:
     508                 :            :                 case AUDIT_SUBJ_TYPE:
     509                 :            :                 case AUDIT_SUBJ_SEN:
     510                 :            :                 case AUDIT_SUBJ_CLR:
     511                 :            :                 case AUDIT_OBJ_USER:
     512                 :            :                 case AUDIT_OBJ_ROLE:
     513                 :            :                 case AUDIT_OBJ_TYPE:
     514                 :            :                 case AUDIT_OBJ_LEV_LOW:
     515                 :            :                 case AUDIT_OBJ_LEV_HIGH:
     516                 :          0 :                         str = audit_unpack_string(&bufp, &remain, f_val);
     517         [ #  # ]:          0 :                         if (IS_ERR(str)) {
     518                 :          0 :                                 err = PTR_ERR(str);
     519                 :          0 :                                 goto exit_free;
     520                 :            :                         }
     521                 :          0 :                         entry->rule.buflen += f_val;
     522                 :          0 :                         f->lsm_str = str;
     523                 :          0 :                         err = security_audit_rule_init(f->type, f->op, str,
     524                 :            :                                                        (void **)&f->lsm_rule);
     525                 :            :                         /* Keep currently invalid fields around in case they
     526                 :            :                          * become valid after a policy reload. */
     527         [ #  # ]:          0 :                         if (err == -EINVAL) {
     528                 :          0 :                                 pr_warn("audit rule for LSM \'%s\' is invalid\n",
     529                 :            :                                         str);
     530                 :          0 :                                 err = 0;
     531         [ #  # ]:          0 :                         } else if (err)
     532                 :          0 :                                 goto exit_free;
     533                 :            :                         break;
     534                 :          0 :                 case AUDIT_WATCH:
     535                 :          0 :                         str = audit_unpack_string(&bufp, &remain, f_val);
     536         [ #  # ]:          0 :                         if (IS_ERR(str)) {
     537                 :          0 :                                 err = PTR_ERR(str);
     538                 :          0 :                                 goto exit_free;
     539                 :            :                         }
     540                 :          0 :                         err = audit_to_watch(&entry->rule, str, f_val, f->op);
     541         [ #  # ]:          0 :                         if (err) {
     542                 :          0 :                                 kfree(str);
     543                 :          0 :                                 goto exit_free;
     544                 :            :                         }
     545                 :          0 :                         entry->rule.buflen += f_val;
     546                 :          0 :                         break;
     547                 :          0 :                 case AUDIT_DIR:
     548                 :          0 :                         str = audit_unpack_string(&bufp, &remain, f_val);
     549         [ #  # ]:          0 :                         if (IS_ERR(str)) {
     550                 :          0 :                                 err = PTR_ERR(str);
     551                 :          0 :                                 goto exit_free;
     552                 :            :                         }
     553                 :          0 :                         err = audit_make_tree(&entry->rule, str, f->op);
     554                 :          0 :                         kfree(str);
     555         [ #  # ]:          0 :                         if (err)
     556                 :          0 :                                 goto exit_free;
     557                 :          0 :                         entry->rule.buflen += f_val;
     558                 :          0 :                         break;
     559                 :          0 :                 case AUDIT_INODE:
     560                 :          0 :                         f->val = f_val;
     561         [ #  # ]:          0 :                         err = audit_to_inode(&entry->rule, f);
     562                 :          0 :                         if (err)
     563                 :          0 :                                 goto exit_free;
     564                 :            :                         break;
     565                 :          0 :                 case AUDIT_FILTERKEY:
     566   [ #  #  #  # ]:          0 :                         if (entry->rule.filterkey || f_val > AUDIT_MAX_KEY_LEN)
     567                 :          0 :                                 goto exit_free;
     568                 :          0 :                         str = audit_unpack_string(&bufp, &remain, f_val);
     569         [ #  # ]:          0 :                         if (IS_ERR(str)) {
     570                 :          0 :                                 err = PTR_ERR(str);
     571                 :          0 :                                 goto exit_free;
     572                 :            :                         }
     573                 :          0 :                         entry->rule.buflen += f_val;
     574                 :          0 :                         entry->rule.filterkey = str;
     575                 :          0 :                         break;
     576                 :          0 :                 case AUDIT_EXE:
     577   [ #  #  #  # ]:          0 :                         if (entry->rule.exe || f_val > PATH_MAX)
     578                 :          0 :                                 goto exit_free;
     579                 :          0 :                         str = audit_unpack_string(&bufp, &remain, f_val);
     580         [ #  # ]:          0 :                         if (IS_ERR(str)) {
     581                 :          0 :                                 err = PTR_ERR(str);
     582                 :          0 :                                 goto exit_free;
     583                 :            :                         }
     584                 :          0 :                         audit_mark = audit_alloc_mark(&entry->rule, str, f_val);
     585         [ #  # ]:          0 :                         if (IS_ERR(audit_mark)) {
     586                 :          0 :                                 kfree(str);
     587                 :          0 :                                 err = PTR_ERR(audit_mark);
     588                 :          0 :                                 goto exit_free;
     589                 :            :                         }
     590                 :          0 :                         entry->rule.buflen += f_val;
     591                 :          0 :                         entry->rule.exe = audit_mark;
     592                 :          0 :                         break;
     593                 :          0 :                 default:
     594                 :          0 :                         f->val = f_val;
     595                 :          0 :                         break;
     596                 :            :                 }
     597                 :            :         }
     598                 :            : 
     599   [ #  #  #  # ]:          0 :         if (entry->rule.inode_f && entry->rule.inode_f->op == Audit_not_equal)
     600                 :          0 :                 entry->rule.inode_f = NULL;
     601                 :            : 
     602                 :          0 : exit_nofree:
     603                 :            :         return entry;
     604                 :            : 
     605                 :          0 : exit_free:
     606         [ #  # ]:          0 :         if (entry->rule.tree)
     607                 :          0 :                 audit_put_tree(entry->rule.tree); /* that's the temporary one */
     608         [ #  # ]:          0 :         if (entry->rule.exe)
     609                 :          0 :                 audit_remove_mark(entry->rule.exe); /* that's the template one */
     610                 :          0 :         audit_free_rule(entry);
     611                 :          0 :         return ERR_PTR(err);
     612                 :            : }
     613                 :            : 
     614                 :            : /* Pack a filter field's string representation into data block. */
     615                 :          0 : static inline size_t audit_pack_string(void **bufp, const char *str)
     616                 :            : {
     617                 :          0 :         size_t len = strlen(str);
     618                 :            : 
     619                 :          0 :         memcpy(*bufp, str, len);
     620                 :          0 :         *bufp += len;
     621                 :            : 
     622                 :          0 :         return len;
     623                 :            : }
     624                 :            : 
     625                 :            : /* Translate kernel rule representation to struct audit_rule_data. */
     626                 :          0 : static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
     627                 :            : {
     628                 :          0 :         struct audit_rule_data *data;
     629                 :          0 :         void *bufp;
     630                 :          0 :         int i;
     631                 :            : 
     632         [ #  # ]:          0 :         data = kmalloc(sizeof(*data) + krule->buflen, GFP_KERNEL);
     633         [ #  # ]:          0 :         if (unlikely(!data))
     634                 :            :                 return NULL;
     635                 :          0 :         memset(data, 0, sizeof(*data));
     636                 :            : 
     637                 :          0 :         data->flags = krule->flags | krule->listnr;
     638                 :          0 :         data->action = krule->action;
     639                 :          0 :         data->field_count = krule->field_count;
     640                 :          0 :         bufp = data->buf;
     641         [ #  # ]:          0 :         for (i = 0; i < data->field_count; i++) {
     642                 :          0 :                 struct audit_field *f = &krule->fields[i];
     643                 :            : 
     644                 :          0 :                 data->fields[i] = f->type;
     645                 :          0 :                 data->fieldflags[i] = audit_ops[f->op];
     646   [ #  #  #  #  :          0 :                 switch(f->type) {
                #  #  # ]
     647                 :          0 :                 case AUDIT_SUBJ_USER:
     648                 :            :                 case AUDIT_SUBJ_ROLE:
     649                 :            :                 case AUDIT_SUBJ_TYPE:
     650                 :            :                 case AUDIT_SUBJ_SEN:
     651                 :            :                 case AUDIT_SUBJ_CLR:
     652                 :            :                 case AUDIT_OBJ_USER:
     653                 :            :                 case AUDIT_OBJ_ROLE:
     654                 :            :                 case AUDIT_OBJ_TYPE:
     655                 :            :                 case AUDIT_OBJ_LEV_LOW:
     656                 :            :                 case AUDIT_OBJ_LEV_HIGH:
     657                 :          0 :                         data->buflen += data->values[i] =
     658                 :          0 :                                 audit_pack_string(&bufp, f->lsm_str);
     659                 :          0 :                         break;
     660                 :          0 :                 case AUDIT_WATCH:
     661                 :          0 :                         data->buflen += data->values[i] =
     662                 :          0 :                                 audit_pack_string(&bufp,
     663                 :          0 :                                                   audit_watch_path(krule->watch));
     664                 :          0 :                         break;
     665                 :          0 :                 case AUDIT_DIR:
     666                 :          0 :                         data->buflen += data->values[i] =
     667                 :          0 :                                 audit_pack_string(&bufp,
     668                 :            :                                                   audit_tree_path(krule->tree));
     669                 :          0 :                         break;
     670                 :          0 :                 case AUDIT_FILTERKEY:
     671                 :          0 :                         data->buflen += data->values[i] =
     672                 :          0 :                                 audit_pack_string(&bufp, krule->filterkey);
     673                 :          0 :                         break;
     674                 :          0 :                 case AUDIT_EXE:
     675                 :          0 :                         data->buflen += data->values[i] =
     676                 :          0 :                                 audit_pack_string(&bufp, audit_mark_path(krule->exe));
     677                 :          0 :                         break;
     678                 :          0 :                 case AUDIT_LOGINUID_SET:
     679   [ #  #  #  # ]:          0 :                         if (krule->pflags & AUDIT_LOGINUID_LEGACY && !f->val) {
     680                 :          0 :                                 data->fields[i] = AUDIT_LOGINUID;
     681                 :          0 :                                 data->values[i] = AUDIT_UID_UNSET;
     682                 :          0 :                                 break;
     683                 :            :                         }
     684                 :            :                         /* fall through - if set */
     685                 :            :                 default:
     686                 :          0 :                         data->values[i] = f->val;
     687                 :            :                 }
     688                 :            :         }
     689         [ #  # ]:          0 :         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) data->mask[i] = krule->mask[i];
     690                 :            : 
     691                 :            :         return data;
     692                 :            : }
     693                 :            : 
     694                 :            : /* Compare two rules in kernel format.  Considered success if rules
     695                 :            :  * don't match. */
     696                 :          0 : static int audit_compare_rule(struct audit_krule *a, struct audit_krule *b)
     697                 :            : {
     698                 :          0 :         int i;
     699                 :            : 
     700         [ #  # ]:          0 :         if (a->flags != b->flags ||
     701                 :            :             a->pflags != b->pflags ||
     702         [ #  # ]:          0 :             a->listnr != b->listnr ||
     703                 :          0 :             a->action != b->action ||
     704         [ #  # ]:          0 :             a->field_count != b->field_count)
     705                 :            :                 return 1;
     706                 :            : 
     707         [ #  # ]:          0 :         for (i = 0; i < a->field_count; i++) {
     708         [ #  # ]:          0 :                 if (a->fields[i].type != b->fields[i].type ||
     709         [ #  # ]:          0 :                     a->fields[i].op != b->fields[i].op)
     710                 :            :                         return 1;
     711                 :            : 
     712   [ #  #  #  #  :          0 :                 switch(a->fields[i].type) {
             #  #  #  # ]
     713                 :          0 :                 case AUDIT_SUBJ_USER:
     714                 :            :                 case AUDIT_SUBJ_ROLE:
     715                 :            :                 case AUDIT_SUBJ_TYPE:
     716                 :            :                 case AUDIT_SUBJ_SEN:
     717                 :            :                 case AUDIT_SUBJ_CLR:
     718                 :            :                 case AUDIT_OBJ_USER:
     719                 :            :                 case AUDIT_OBJ_ROLE:
     720                 :            :                 case AUDIT_OBJ_TYPE:
     721                 :            :                 case AUDIT_OBJ_LEV_LOW:
     722                 :            :                 case AUDIT_OBJ_LEV_HIGH:
     723         [ #  # ]:          0 :                         if (strcmp(a->fields[i].lsm_str, b->fields[i].lsm_str))
     724                 :            :                                 return 1;
     725                 :            :                         break;
     726                 :          0 :                 case AUDIT_WATCH:
     727         [ #  # ]:          0 :                         if (strcmp(audit_watch_path(a->watch),
     728                 :          0 :                                    audit_watch_path(b->watch)))
     729                 :            :                                 return 1;
     730                 :            :                         break;
     731                 :          0 :                 case AUDIT_DIR:
     732         [ #  # ]:          0 :                         if (strcmp(audit_tree_path(a->tree),
     733                 :            :                                    audit_tree_path(b->tree)))
     734                 :            :                                 return 1;
     735                 :            :                         break;
     736                 :          0 :                 case AUDIT_FILTERKEY:
     737                 :            :                         /* both filterkeys exist based on above type compare */
     738         [ #  # ]:          0 :                         if (strcmp(a->filterkey, b->filterkey))
     739                 :            :                                 return 1;
     740                 :            :                         break;
     741                 :          0 :                 case AUDIT_EXE:
     742                 :            :                         /* both paths exist based on above type compare */
     743         [ #  # ]:          0 :                         if (strcmp(audit_mark_path(a->exe),
     744                 :          0 :                                    audit_mark_path(b->exe)))
     745                 :            :                                 return 1;
     746                 :            :                         break;
     747                 :          0 :                 case AUDIT_UID:
     748                 :            :                 case AUDIT_EUID:
     749                 :            :                 case AUDIT_SUID:
     750                 :            :                 case AUDIT_FSUID:
     751                 :            :                 case AUDIT_LOGINUID:
     752                 :            :                 case AUDIT_OBJ_UID:
     753         [ #  # ]:          0 :                         if (!uid_eq(a->fields[i].uid, b->fields[i].uid))
     754                 :            :                                 return 1;
     755                 :            :                         break;
     756                 :          0 :                 case AUDIT_GID:
     757                 :            :                 case AUDIT_EGID:
     758                 :            :                 case AUDIT_SGID:
     759                 :            :                 case AUDIT_FSGID:
     760                 :            :                 case AUDIT_OBJ_GID:
     761         [ #  # ]:          0 :                         if (!gid_eq(a->fields[i].gid, b->fields[i].gid))
     762                 :            :                                 return 1;
     763                 :            :                         break;
     764                 :          0 :                 default:
     765         [ #  # ]:          0 :                         if (a->fields[i].val != b->fields[i].val)
     766                 :            :                                 return 1;
     767                 :            :                 }
     768                 :            :         }
     769                 :            : 
     770         [ #  # ]:          0 :         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
     771         [ #  # ]:          0 :                 if (a->mask[i] != b->mask[i])
     772                 :            :                         return 1;
     773                 :            : 
     774                 :            :         return 0;
     775                 :            : }
     776                 :            : 
     777                 :            : /* Duplicate LSM field information.  The lsm_rule is opaque, so must be
     778                 :            :  * re-initialized. */
     779                 :            : static inline int audit_dupe_lsm_field(struct audit_field *df,
     780                 :            :                                            struct audit_field *sf)
     781                 :            : {
     782                 :            :         int ret = 0;
     783                 :            :         char *lsm_str;
     784                 :            : 
     785                 :            :         /* our own copy of lsm_str */
     786                 :            :         lsm_str = kstrdup(sf->lsm_str, GFP_KERNEL);
     787                 :            :         if (unlikely(!lsm_str))
     788                 :            :                 return -ENOMEM;
     789                 :            :         df->lsm_str = lsm_str;
     790                 :            : 
     791                 :            :         /* our own (refreshed) copy of lsm_rule */
     792                 :            :         ret = security_audit_rule_init(df->type, df->op, df->lsm_str,
     793                 :            :                                        (void **)&df->lsm_rule);
     794                 :            :         /* Keep currently invalid fields around in case they
     795                 :            :          * become valid after a policy reload. */
     796                 :            :         if (ret == -EINVAL) {
     797                 :            :                 pr_warn("audit rule for LSM \'%s\' is invalid\n",
     798                 :            :                         df->lsm_str);
     799                 :            :                 ret = 0;
     800                 :            :         }
     801                 :            : 
     802                 :            :         return ret;
     803                 :            : }
     804                 :            : 
     805                 :            : /* Duplicate an audit rule.  This will be a deep copy with the exception
     806                 :            :  * of the watch - that pointer is carried over.  The LSM specific fields
     807                 :            :  * will be updated in the copy.  The point is to be able to replace the old
     808                 :            :  * rule with the new rule in the filterlist, then free the old rule.
     809                 :            :  * The rlist element is undefined; list manipulations are handled apart from
     810                 :            :  * the initial copy. */
     811                 :          0 : struct audit_entry *audit_dupe_rule(struct audit_krule *old)
     812                 :            : {
     813                 :          0 :         u32 fcount = old->field_count;
     814                 :          0 :         struct audit_entry *entry;
     815                 :          0 :         struct audit_krule *new;
     816                 :          0 :         char *fk;
     817                 :          0 :         int i, err = 0;
     818                 :            : 
     819                 :          0 :         entry = audit_init_entry(fcount);
     820         [ #  # ]:          0 :         if (unlikely(!entry))
     821                 :            :                 return ERR_PTR(-ENOMEM);
     822                 :            : 
     823                 :          0 :         new = &entry->rule;
     824                 :          0 :         new->flags = old->flags;
     825                 :          0 :         new->pflags = old->pflags;
     826                 :          0 :         new->listnr = old->listnr;
     827                 :          0 :         new->action = old->action;
     828         [ #  # ]:          0 :         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
     829                 :          0 :                 new->mask[i] = old->mask[i];
     830                 :          0 :         new->prio = old->prio;
     831                 :          0 :         new->buflen = old->buflen;
     832                 :          0 :         new->inode_f = old->inode_f;
     833                 :          0 :         new->field_count = old->field_count;
     834                 :            : 
     835                 :            :         /*
     836                 :            :          * note that we are OK with not refcounting here; audit_match_tree()
     837                 :            :          * never dereferences tree and we can't get false positives there
     838                 :            :          * since we'd have to have rule gone from the list *and* removed
     839                 :            :          * before the chunks found by lookup had been allocated, i.e. before
     840                 :            :          * the beginning of list scan.
     841                 :            :          */
     842                 :          0 :         new->tree = old->tree;
     843                 :          0 :         memcpy(new->fields, old->fields, sizeof(struct audit_field) * fcount);
     844                 :            : 
     845                 :            :         /* deep copy this information, updating the lsm_rule fields, because
     846                 :            :          * the originals will all be freed when the old rule is freed. */
     847         [ #  # ]:          0 :         for (i = 0; i < fcount; i++) {
     848   [ #  #  #  # ]:          0 :                 switch (new->fields[i].type) {
     849                 :          0 :                 case AUDIT_SUBJ_USER:
     850                 :            :                 case AUDIT_SUBJ_ROLE:
     851                 :            :                 case AUDIT_SUBJ_TYPE:
     852                 :            :                 case AUDIT_SUBJ_SEN:
     853                 :            :                 case AUDIT_SUBJ_CLR:
     854                 :            :                 case AUDIT_OBJ_USER:
     855                 :            :                 case AUDIT_OBJ_ROLE:
     856                 :            :                 case AUDIT_OBJ_TYPE:
     857                 :            :                 case AUDIT_OBJ_LEV_LOW:
     858                 :            :                 case AUDIT_OBJ_LEV_HIGH:
     859                 :          0 :                         err = audit_dupe_lsm_field(&new->fields[i],
     860                 :          0 :                                                        &old->fields[i]);
     861                 :          0 :                         break;
     862                 :          0 :                 case AUDIT_FILTERKEY:
     863                 :          0 :                         fk = kstrdup(old->filterkey, GFP_KERNEL);
     864         [ #  # ]:          0 :                         if (unlikely(!fk))
     865                 :            :                                 err = -ENOMEM;
     866                 :            :                         else
     867                 :          0 :                                 new->filterkey = fk;
     868                 :            :                         break;
     869                 :          0 :                 case AUDIT_EXE:
     870                 :          0 :                         err = audit_dupe_exe(new, old);
     871                 :          0 :                         break;
     872                 :            :                 }
     873         [ #  # ]:          0 :                 if (err) {
     874         [ #  # ]:          0 :                         if (new->exe)
     875                 :          0 :                                 audit_remove_mark(new->exe);
     876                 :          0 :                         audit_free_rule(entry);
     877                 :          0 :                         return ERR_PTR(err);
     878                 :            :                 }
     879                 :            :         }
     880                 :            : 
     881         [ #  # ]:          0 :         if (old->watch) {
     882                 :          0 :                 audit_get_watch(old->watch);
     883                 :          0 :                 new->watch = old->watch;
     884                 :            :         }
     885                 :            : 
     886                 :            :         return entry;
     887                 :            : }
     888                 :            : 
     889                 :            : /* Find an existing audit rule.
     890                 :            :  * Caller must hold audit_filter_mutex to prevent stale rule data. */
     891                 :          0 : static struct audit_entry *audit_find_rule(struct audit_entry *entry,
     892                 :            :                                            struct list_head **p)
     893                 :            : {
     894                 :          0 :         struct audit_entry *e, *found = NULL;
     895                 :          0 :         struct list_head *list;
     896                 :          0 :         int h;
     897                 :            : 
     898         [ #  # ]:          0 :         if (entry->rule.inode_f) {
     899                 :          0 :                 h = audit_hash_ino(entry->rule.inode_f->val);
     900                 :          0 :                 *p = list = &audit_inode_hash[h];
     901         [ #  # ]:          0 :         } else if (entry->rule.watch) {
     902                 :            :                 /* we don't know the inode number, so must walk entire hash */
     903         [ #  # ]:          0 :                 for (h = 0; h < AUDIT_INODE_BUCKETS; h++) {
     904                 :          0 :                         list = &audit_inode_hash[h];
     905         [ #  # ]:          0 :                         list_for_each_entry(e, list, list)
     906         [ #  # ]:          0 :                                 if (!audit_compare_rule(&entry->rule, &e->rule)) {
     907                 :          0 :                                         found = e;
     908                 :          0 :                                         goto out;
     909                 :            :                                 }
     910                 :            :                 }
     911                 :          0 :                 goto out;
     912                 :            :         } else {
     913                 :          0 :                 *p = list = &audit_filter_list[entry->rule.listnr];
     914                 :            :         }
     915                 :            : 
     916         [ #  # ]:          0 :         list_for_each_entry(e, list, list)
     917         [ #  # ]:          0 :                 if (!audit_compare_rule(&entry->rule, &e->rule)) {
     918                 :          0 :                         found = e;
     919                 :          0 :                         goto out;
     920                 :            :                 }
     921                 :            : 
     922                 :          0 : out:
     923                 :          0 :         return found;
     924                 :            : }
     925                 :            : 
     926                 :            : static u64 prio_low = ~0ULL/2;
     927                 :            : static u64 prio_high = ~0ULL/2 - 1;
     928                 :            : 
     929                 :            : /* Add rule to given filterlist if not a duplicate. */
     930                 :          0 : static inline int audit_add_rule(struct audit_entry *entry)
     931                 :            : {
     932                 :          0 :         struct audit_entry *e;
     933                 :          0 :         struct audit_watch *watch = entry->rule.watch;
     934                 :          0 :         struct audit_tree *tree = entry->rule.tree;
     935                 :          0 :         struct list_head *list;
     936                 :          0 :         int err = 0;
     937                 :            : #ifdef CONFIG_AUDITSYSCALL
     938                 :          0 :         int dont_count = 0;
     939                 :            : 
     940                 :            :         /* If any of these, don't count towards total */
     941         [ #  # ]:          0 :         switch(entry->rule.listnr) {
     942                 :          0 :         case AUDIT_FILTER_USER:
     943                 :            :         case AUDIT_FILTER_EXCLUDE:
     944                 :            :         case AUDIT_FILTER_FS:
     945                 :          0 :                 dont_count = 1;
     946                 :            :         }
     947                 :            : #endif
     948                 :            : 
     949                 :          0 :         mutex_lock(&audit_filter_mutex);
     950                 :          0 :         e = audit_find_rule(entry, &list);
     951         [ #  # ]:          0 :         if (e) {
     952                 :          0 :                 mutex_unlock(&audit_filter_mutex);
     953                 :          0 :                 err = -EEXIST;
     954                 :            :                 /* normally audit_add_tree_rule() will free it on failure */
     955         [ #  # ]:          0 :                 if (tree)
     956                 :          0 :                         audit_put_tree(tree);
     957                 :          0 :                 return err;
     958                 :            :         }
     959                 :            : 
     960         [ #  # ]:          0 :         if (watch) {
     961                 :            :                 /* audit_filter_mutex is dropped and re-taken during this call */
     962                 :          0 :                 err = audit_add_watch(&entry->rule, &list);
     963         [ #  # ]:          0 :                 if (err) {
     964                 :          0 :                         mutex_unlock(&audit_filter_mutex);
     965                 :            :                         /*
     966                 :            :                          * normally audit_add_tree_rule() will free it
     967                 :            :                          * on failure
     968                 :            :                          */
     969         [ #  # ]:          0 :                         if (tree)
     970                 :          0 :                                 audit_put_tree(tree);
     971                 :          0 :                         return err;
     972                 :            :                 }
     973                 :            :         }
     974         [ #  # ]:          0 :         if (tree) {
     975                 :          0 :                 err = audit_add_tree_rule(&entry->rule);
     976         [ #  # ]:          0 :                 if (err) {
     977                 :          0 :                         mutex_unlock(&audit_filter_mutex);
     978                 :          0 :                         return err;
     979                 :            :                 }
     980                 :            :         }
     981                 :            : 
     982                 :          0 :         entry->rule.prio = ~0ULL;
     983         [ #  # ]:          0 :         if (entry->rule.listnr == AUDIT_FILTER_EXIT) {
     984         [ #  # ]:          0 :                 if (entry->rule.flags & AUDIT_FILTER_PREPEND)
     985                 :          0 :                         entry->rule.prio = ++prio_high;
     986                 :            :                 else
     987                 :          0 :                         entry->rule.prio = --prio_low;
     988                 :            :         }
     989                 :            : 
     990         [ #  # ]:          0 :         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
     991                 :          0 :                 list_add(&entry->rule.list,
     992                 :            :                          &audit_rules_list[entry->rule.listnr]);
     993                 :          0 :                 list_add_rcu(&entry->list, list);
     994                 :          0 :                 entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
     995                 :            :         } else {
     996                 :          0 :                 list_add_tail(&entry->rule.list,
     997                 :            :                               &audit_rules_list[entry->rule.listnr]);
     998                 :          0 :                 list_add_tail_rcu(&entry->list, list);
     999                 :            :         }
    1000                 :            : #ifdef CONFIG_AUDITSYSCALL
    1001         [ #  # ]:          0 :         if (!dont_count)
    1002                 :          0 :                 audit_n_rules++;
    1003                 :            : 
    1004         [ #  # ]:          0 :         if (!audit_match_signal(entry))
    1005                 :          0 :                 audit_signals++;
    1006                 :            : #endif
    1007                 :          0 :         mutex_unlock(&audit_filter_mutex);
    1008                 :            : 
    1009                 :          0 :         return err;
    1010                 :            : }
    1011                 :            : 
    1012                 :            : /* Remove an existing rule from filterlist. */
    1013                 :          0 : int audit_del_rule(struct audit_entry *entry)
    1014                 :            : {
    1015                 :          0 :         struct audit_entry  *e;
    1016                 :          0 :         struct audit_tree *tree = entry->rule.tree;
    1017                 :          0 :         struct list_head *list;
    1018                 :          0 :         int ret = 0;
    1019                 :            : #ifdef CONFIG_AUDITSYSCALL
    1020                 :          0 :         int dont_count = 0;
    1021                 :            : 
    1022                 :            :         /* If any of these, don't count towards total */
    1023         [ #  # ]:          0 :         switch(entry->rule.listnr) {
    1024                 :          0 :         case AUDIT_FILTER_USER:
    1025                 :            :         case AUDIT_FILTER_EXCLUDE:
    1026                 :            :         case AUDIT_FILTER_FS:
    1027                 :          0 :                 dont_count = 1;
    1028                 :            :         }
    1029                 :            : #endif
    1030                 :            : 
    1031                 :          0 :         mutex_lock(&audit_filter_mutex);
    1032                 :          0 :         e = audit_find_rule(entry, &list);
    1033         [ #  # ]:          0 :         if (!e) {
    1034                 :          0 :                 ret = -ENOENT;
    1035                 :          0 :                 goto out;
    1036                 :            :         }
    1037                 :            : 
    1038         [ #  # ]:          0 :         if (e->rule.watch)
    1039                 :          0 :                 audit_remove_watch_rule(&e->rule);
    1040                 :            : 
    1041         [ #  # ]:          0 :         if (e->rule.tree)
    1042                 :          0 :                 audit_remove_tree_rule(&e->rule);
    1043                 :            : 
    1044         [ #  # ]:          0 :         if (e->rule.exe)
    1045                 :          0 :                 audit_remove_mark_rule(&e->rule);
    1046                 :            : 
    1047                 :            : #ifdef CONFIG_AUDITSYSCALL
    1048         [ #  # ]:          0 :         if (!dont_count)
    1049                 :          0 :                 audit_n_rules--;
    1050                 :            : 
    1051         [ #  # ]:          0 :         if (!audit_match_signal(entry))
    1052                 :          0 :                 audit_signals--;
    1053                 :            : #endif
    1054                 :            : 
    1055                 :          0 :         list_del_rcu(&e->list);
    1056                 :          0 :         list_del(&e->rule.list);
    1057                 :          0 :         call_rcu(&e->rcu, audit_free_rule_rcu);
    1058                 :            : 
    1059                 :          0 : out:
    1060                 :          0 :         mutex_unlock(&audit_filter_mutex);
    1061                 :            : 
    1062         [ #  # ]:          0 :         if (tree)
    1063                 :          0 :                 audit_put_tree(tree);   /* that's the temporary one */
    1064                 :            : 
    1065                 :          0 :         return ret;
    1066                 :            : }
    1067                 :            : 
    1068                 :            : /* List rules using struct audit_rule_data. */
    1069                 :          0 : static void audit_list_rules(int seq, struct sk_buff_head *q)
    1070                 :            : {
    1071                 :          0 :         struct sk_buff *skb;
    1072                 :          0 :         struct audit_krule *r;
    1073                 :          0 :         int i;
    1074                 :            : 
    1075                 :            :         /* This is a blocking read, so use audit_filter_mutex instead of rcu
    1076                 :            :          * iterator to sync with list writers. */
    1077         [ #  # ]:          0 :         for (i=0; i<AUDIT_NR_FILTERS; i++) {
    1078         [ #  # ]:          0 :                 list_for_each_entry(r, &audit_rules_list[i], list) {
    1079                 :          0 :                         struct audit_rule_data *data;
    1080                 :            : 
    1081                 :          0 :                         data = audit_krule_to_data(r);
    1082         [ #  # ]:          0 :                         if (unlikely(!data))
    1083                 :            :                                 break;
    1084                 :          0 :                         skb = audit_make_reply(seq, AUDIT_LIST_RULES, 0, 1,
    1085                 :            :                                                data,
    1086                 :          0 :                                                sizeof(*data) + data->buflen);
    1087         [ #  # ]:          0 :                         if (skb)
    1088                 :          0 :                                 skb_queue_tail(q, skb);
    1089                 :          0 :                         kfree(data);
    1090                 :            :                 }
    1091                 :            :         }
    1092                 :          0 :         skb = audit_make_reply(seq, AUDIT_LIST_RULES, 1, 1, NULL, 0);
    1093         [ #  # ]:          0 :         if (skb)
    1094                 :          0 :                 skb_queue_tail(q, skb);
    1095                 :          0 : }
    1096                 :            : 
    1097                 :            : /* Log rule additions and removals */
    1098                 :            : static void audit_log_rule_change(char *action, struct audit_krule *rule, int res)
    1099                 :            : {
    1100                 :            :         struct audit_buffer *ab;
    1101                 :            : 
    1102                 :            :         if (!audit_enabled)
    1103                 :            :                 return;
    1104                 :            : 
    1105                 :            :         ab = audit_log_start(audit_context(), GFP_KERNEL, AUDIT_CONFIG_CHANGE);
    1106                 :            :         if (!ab)
    1107                 :            :                 return;
    1108                 :            :         audit_log_session_info(ab);
    1109                 :            :         audit_log_task_context(ab);
    1110                 :            :         audit_log_format(ab, " op=%s", action);
    1111                 :            :         audit_log_key(ab, rule->filterkey);
    1112                 :            :         audit_log_format(ab, " list=%d res=%d", rule->listnr, res);
    1113                 :            :         audit_log_end(ab);
    1114                 :            : }
    1115                 :            : 
    1116                 :            : /**
    1117                 :            :  * audit_rule_change - apply all rules to the specified message type
    1118                 :            :  * @type: audit message type
    1119                 :            :  * @seq: netlink audit message sequence (serial) number
    1120                 :            :  * @data: payload data
    1121                 :            :  * @datasz: size of payload data
    1122                 :            :  */
    1123                 :          0 : int audit_rule_change(int type, int seq, void *data, size_t datasz)
    1124                 :            : {
    1125                 :          0 :         int err = 0;
    1126                 :          0 :         struct audit_entry *entry;
    1127                 :            : 
    1128      [ #  #  # ]:          0 :         switch (type) {
    1129                 :          0 :         case AUDIT_ADD_RULE:
    1130                 :          0 :                 entry = audit_data_to_entry(data, datasz);
    1131         [ #  # ]:          0 :                 if (IS_ERR(entry))
    1132                 :          0 :                         return PTR_ERR(entry);
    1133                 :          0 :                 err = audit_add_rule(entry);
    1134                 :          0 :                 audit_log_rule_change("add_rule", &entry->rule, !err);
    1135                 :          0 :                 break;
    1136                 :          0 :         case AUDIT_DEL_RULE:
    1137                 :          0 :                 entry = audit_data_to_entry(data, datasz);
    1138         [ #  # ]:          0 :                 if (IS_ERR(entry))
    1139                 :          0 :                         return PTR_ERR(entry);
    1140                 :          0 :                 err = audit_del_rule(entry);
    1141                 :          0 :                 audit_log_rule_change("remove_rule", &entry->rule, !err);
    1142                 :          0 :                 break;
    1143                 :            :         default:
    1144                 :          0 :                 WARN_ON(1);
    1145                 :          0 :                 return -EINVAL;
    1146                 :            :         }
    1147                 :            : 
    1148         [ #  # ]:          0 :         if (err || type == AUDIT_DEL_RULE) {
    1149         [ #  # ]:          0 :                 if (entry->rule.exe)
    1150                 :          0 :                         audit_remove_mark(entry->rule.exe);
    1151                 :          0 :                 audit_free_rule(entry);
    1152                 :            :         }
    1153                 :            : 
    1154                 :            :         return err;
    1155                 :            : }
    1156                 :            : 
    1157                 :            : /**
    1158                 :            :  * audit_list_rules_send - list the audit rules
    1159                 :            :  * @request_skb: skb of request we are replying to (used to target the reply)
    1160                 :            :  * @seq: netlink audit message sequence (serial) number
    1161                 :            :  */
    1162                 :          0 : int audit_list_rules_send(struct sk_buff *request_skb, int seq)
    1163                 :            : {
    1164                 :          0 :         u32 portid = NETLINK_CB(request_skb).portid;
    1165                 :          0 :         struct net *net = sock_net(NETLINK_CB(request_skb).sk);
    1166                 :          0 :         struct task_struct *tsk;
    1167                 :          0 :         struct audit_netlink_list *dest;
    1168                 :          0 :         int err = 0;
    1169                 :            : 
    1170                 :            :         /* We can't just spew out the rules here because we might fill
    1171                 :            :          * the available socket buffer space and deadlock waiting for
    1172                 :            :          * auditctl to read from it... which isn't ever going to
    1173                 :            :          * happen if we're actually running in the context of auditctl
    1174                 :            :          * trying to _send_ the stuff */
    1175                 :            : 
    1176                 :          0 :         dest = kmalloc(sizeof(struct audit_netlink_list), GFP_KERNEL);
    1177         [ #  # ]:          0 :         if (!dest)
    1178                 :            :                 return -ENOMEM;
    1179                 :          0 :         dest->net = get_net(net);
    1180                 :          0 :         dest->portid = portid;
    1181                 :          0 :         skb_queue_head_init(&dest->q);
    1182                 :            : 
    1183                 :          0 :         mutex_lock(&audit_filter_mutex);
    1184                 :          0 :         audit_list_rules(seq, &dest->q);
    1185                 :          0 :         mutex_unlock(&audit_filter_mutex);
    1186                 :            : 
    1187         [ #  # ]:          0 :         tsk = kthread_run(audit_send_list, dest, "audit_send_list");
    1188         [ #  # ]:          0 :         if (IS_ERR(tsk)) {
    1189                 :          0 :                 skb_queue_purge(&dest->q);
    1190                 :          0 :                 kfree(dest);
    1191                 :          0 :                 err = PTR_ERR(tsk);
    1192                 :            :         }
    1193                 :            : 
    1194                 :            :         return err;
    1195                 :            : }
    1196                 :            : 
    1197                 :          0 : int audit_comparator(u32 left, u32 op, u32 right)
    1198                 :            : {
    1199   [ #  #  #  #  :          0 :         switch (op) {
             #  #  #  #  
                      # ]
    1200                 :          0 :         case Audit_equal:
    1201                 :          0 :                 return (left == right);
    1202                 :          0 :         case Audit_not_equal:
    1203                 :          0 :                 return (left != right);
    1204                 :          0 :         case Audit_lt:
    1205                 :          0 :                 return (left < right);
    1206                 :          0 :         case Audit_le:
    1207                 :          0 :                 return (left <= right);
    1208                 :          0 :         case Audit_gt:
    1209                 :          0 :                 return (left > right);
    1210                 :          0 :         case Audit_ge:
    1211                 :          0 :                 return (left >= right);
    1212                 :          0 :         case Audit_bitmask:
    1213                 :          0 :                 return (left & right);
    1214                 :          0 :         case Audit_bittest:
    1215                 :          0 :                 return ((left & right) == right);
    1216                 :            :         default:
    1217                 :            :                 return 0;
    1218                 :            :         }
    1219                 :            : }
    1220                 :            : 
    1221                 :          0 : int audit_uid_comparator(kuid_t left, u32 op, kuid_t right)
    1222                 :            : {
    1223   [ #  #  #  #  :          0 :         switch (op) {
                #  #  # ]
    1224                 :          0 :         case Audit_equal:
    1225                 :          0 :                 return uid_eq(left, right);
    1226                 :          0 :         case Audit_not_equal:
    1227                 :          0 :                 return !uid_eq(left, right);
    1228                 :          0 :         case Audit_lt:
    1229                 :          0 :                 return uid_lt(left, right);
    1230                 :          0 :         case Audit_le:
    1231                 :          0 :                 return uid_lte(left, right);
    1232                 :          0 :         case Audit_gt:
    1233                 :          0 :                 return uid_gt(left, right);
    1234                 :          0 :         case Audit_ge:
    1235                 :          0 :                 return uid_gte(left, right);
    1236                 :            :         case Audit_bitmask:
    1237                 :            :         case Audit_bittest:
    1238                 :            :         default:
    1239                 :            :                 return 0;
    1240                 :            :         }
    1241                 :            : }
    1242                 :            : 
    1243                 :          0 : int audit_gid_comparator(kgid_t left, u32 op, kgid_t right)
    1244                 :            : {
    1245   [ #  #  #  #  :          0 :         switch (op) {
                #  #  # ]
    1246                 :          0 :         case Audit_equal:
    1247                 :          0 :                 return gid_eq(left, right);
    1248                 :          0 :         case Audit_not_equal:
    1249                 :          0 :                 return !gid_eq(left, right);
    1250                 :          0 :         case Audit_lt:
    1251                 :          0 :                 return gid_lt(left, right);
    1252                 :          0 :         case Audit_le:
    1253                 :          0 :                 return gid_lte(left, right);
    1254                 :          0 :         case Audit_gt:
    1255                 :          0 :                 return gid_gt(left, right);
    1256                 :          0 :         case Audit_ge:
    1257                 :          0 :                 return gid_gte(left, right);
    1258                 :            :         case Audit_bitmask:
    1259                 :            :         case Audit_bittest:
    1260                 :            :         default:
    1261                 :            :                 return 0;
    1262                 :            :         }
    1263                 :            : }
    1264                 :            : 
    1265                 :            : /**
    1266                 :            :  * parent_len - find the length of the parent portion of a pathname
    1267                 :            :  * @path: pathname of which to determine length
    1268                 :            :  */
    1269                 :          0 : int parent_len(const char *path)
    1270                 :            : {
    1271                 :          0 :         int plen;
    1272                 :          0 :         const char *p;
    1273                 :            : 
    1274                 :          0 :         plen = strlen(path);
    1275                 :            : 
    1276         [ #  # ]:          0 :         if (plen == 0)
    1277                 :            :                 return plen;
    1278                 :            : 
    1279                 :            :         /* disregard trailing slashes */
    1280                 :          0 :         p = path + plen - 1;
    1281   [ #  #  #  # ]:          0 :         while ((*p == '/') && (p > path))
    1282                 :          0 :                 p--;
    1283                 :            : 
    1284                 :            :         /* walk backward until we find the next slash or hit beginning */
    1285   [ #  #  #  # ]:          0 :         while ((*p != '/') && (p > path))
    1286                 :          0 :                 p--;
    1287                 :            : 
    1288                 :            :         /* did we find a slash? Then increment to include it in path */
    1289         [ #  # ]:          0 :         if (*p == '/')
    1290                 :          0 :                 p++;
    1291                 :            : 
    1292                 :          0 :         return p - path;
    1293                 :            : }
    1294                 :            : 
    1295                 :            : /**
    1296                 :            :  * audit_compare_dname_path - compare given dentry name with last component in
    1297                 :            :  *                            given path. Return of 0 indicates a match.
    1298                 :            :  * @dname:      dentry name that we're comparing
    1299                 :            :  * @path:       full pathname that we're comparing
    1300                 :            :  * @parentlen:  length of the parent if known. Passing in AUDIT_NAME_FULL
    1301                 :            :  *              here indicates that we must compute this value.
    1302                 :            :  */
    1303                 :          0 : int audit_compare_dname_path(const struct qstr *dname, const char *path, int parentlen)
    1304                 :            : {
    1305                 :          0 :         int dlen, pathlen;
    1306                 :          0 :         const char *p;
    1307                 :            : 
    1308                 :          0 :         dlen = dname->len;
    1309                 :          0 :         pathlen = strlen(path);
    1310         [ #  # ]:          0 :         if (pathlen < dlen)
    1311                 :            :                 return 1;
    1312                 :            : 
    1313         [ #  # ]:          0 :         parentlen = parentlen == AUDIT_NAME_FULL ? parent_len(path) : parentlen;
    1314         [ #  # ]:          0 :         if (pathlen - parentlen != dlen)
    1315                 :            :                 return 1;
    1316                 :            : 
    1317                 :          0 :         p = path + parentlen;
    1318                 :            : 
    1319                 :          0 :         return strncmp(p, dname->name, dlen);
    1320                 :            : }
    1321                 :            : 
    1322                 :         78 : int audit_filter(int msgtype, unsigned int listtype)
    1323                 :            : {
    1324                 :         78 :         struct audit_entry *e;
    1325                 :         78 :         int ret = 1; /* Audit by default */
    1326                 :            : 
    1327                 :         78 :         rcu_read_lock();
    1328         [ -  + ]:         78 :         list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) {
    1329                 :            :                 int i, result = 0;
    1330                 :            : 
    1331         [ #  # ]:          0 :                 for (i = 0; i < e->rule.field_count; i++) {
    1332                 :          0 :                         struct audit_field *f = &e->rule.fields[i];
    1333                 :          0 :                         pid_t pid;
    1334                 :          0 :                         u32 sid;
    1335                 :            : 
    1336   [ #  #  #  #  :          0 :                         switch (f->type) {
             #  #  #  #  
                      # ]
    1337                 :            :                         case AUDIT_PID:
    1338                 :          0 :                                 pid = task_pid_nr(current);
    1339                 :          0 :                                 result = audit_comparator(pid, f->op, f->val);
    1340                 :          0 :                                 break;
    1341                 :          0 :                         case AUDIT_UID:
    1342                 :          0 :                                 result = audit_uid_comparator(current_uid(), f->op, f->uid);
    1343                 :          0 :                                 break;
    1344                 :          0 :                         case AUDIT_GID:
    1345                 :          0 :                                 result = audit_gid_comparator(current_gid(), f->op, f->gid);
    1346                 :          0 :                                 break;
    1347                 :          0 :                         case AUDIT_LOGINUID:
    1348                 :          0 :                                 result = audit_uid_comparator(audit_get_loginuid(current),
    1349                 :            :                                                               f->op, f->uid);
    1350                 :          0 :                                 break;
    1351                 :          0 :                         case AUDIT_LOGINUID_SET:
    1352                 :          0 :                                 result = audit_comparator(audit_loginuid_set(current),
    1353                 :            :                                                           f->op, f->val);
    1354                 :          0 :                                 break;
    1355                 :          0 :                         case AUDIT_MSGTYPE:
    1356                 :          0 :                                 result = audit_comparator(msgtype, f->op, f->val);
    1357                 :          0 :                                 break;
    1358                 :          0 :                         case AUDIT_SUBJ_USER:
    1359                 :            :                         case AUDIT_SUBJ_ROLE:
    1360                 :            :                         case AUDIT_SUBJ_TYPE:
    1361                 :            :                         case AUDIT_SUBJ_SEN:
    1362                 :            :                         case AUDIT_SUBJ_CLR:
    1363         [ #  # ]:          0 :                                 if (f->lsm_rule) {
    1364                 :          0 :                                         security_task_getsecid(current, &sid);
    1365                 :          0 :                                         result = security_audit_rule_match(sid,
    1366                 :            :                                                    f->type, f->op, f->lsm_rule);
    1367                 :            :                                 }
    1368                 :            :                                 break;
    1369                 :          0 :                         case AUDIT_EXE:
    1370                 :          0 :                                 result = audit_exe_compare(current, e->rule.exe);
    1371         [ #  # ]:          0 :                                 if (f->op == Audit_not_equal)
    1372                 :          0 :                                         result = !result;
    1373                 :            :                                 break;
    1374                 :          0 :                         default:
    1375                 :          0 :                                 goto unlock_and_return;
    1376                 :            :                         }
    1377         [ #  # ]:          0 :                         if (result < 0) /* error */
    1378                 :          0 :                                 goto unlock_and_return;
    1379         [ #  # ]:          0 :                         if (!result)
    1380                 :            :                                 break;
    1381                 :            :                 }
    1382         [ #  # ]:          0 :                 if (result > 0) {
    1383   [ #  #  #  # ]:          0 :                         if (e->rule.action == AUDIT_NEVER || listtype == AUDIT_FILTER_EXCLUDE)
    1384                 :          0 :                                 ret = 0;
    1385                 :            :                         break;
    1386                 :            :                 }
    1387                 :            :         }
    1388                 :         78 : unlock_and_return:
    1389                 :         78 :         rcu_read_unlock();
    1390                 :         78 :         return ret;
    1391                 :            : }
    1392                 :            : 
    1393                 :          0 : static int update_lsm_rule(struct audit_krule *r)
    1394                 :            : {
    1395                 :          0 :         struct audit_entry *entry = container_of(r, struct audit_entry, rule);
    1396                 :          0 :         struct audit_entry *nentry;
    1397                 :          0 :         int err = 0;
    1398                 :            : 
    1399         [ #  # ]:          0 :         if (!security_audit_rule_known(r))
    1400                 :            :                 return 0;
    1401                 :            : 
    1402                 :          0 :         nentry = audit_dupe_rule(r);
    1403         [ #  # ]:          0 :         if (entry->rule.exe)
    1404                 :          0 :                 audit_remove_mark(entry->rule.exe);
    1405         [ #  # ]:          0 :         if (IS_ERR(nentry)) {
    1406                 :            :                 /* save the first error encountered for the
    1407                 :            :                  * return value */
    1408                 :          0 :                 err = PTR_ERR(nentry);
    1409                 :          0 :                 audit_panic("error updating LSM filters");
    1410         [ #  # ]:          0 :                 if (r->watch)
    1411                 :          0 :                         list_del(&r->rlist);
    1412                 :          0 :                 list_del_rcu(&entry->list);
    1413                 :          0 :                 list_del(&r->list);
    1414                 :            :         } else {
    1415   [ #  #  #  # ]:          0 :                 if (r->watch || r->tree)
    1416                 :          0 :                         list_replace_init(&r->rlist, &nentry->rule.rlist);
    1417                 :          0 :                 list_replace_rcu(&entry->list, &nentry->list);
    1418                 :          0 :                 list_replace(&r->list, &nentry->rule.list);
    1419                 :            :         }
    1420                 :          0 :         call_rcu(&entry->rcu, audit_free_rule_rcu);
    1421                 :            : 
    1422                 :          0 :         return err;
    1423                 :            : }
    1424                 :            : 
    1425                 :            : /* This function will re-initialize the lsm_rule field of all applicable rules.
    1426                 :            :  * It will traverse the filter lists serarching for rules that contain LSM
    1427                 :            :  * specific filter fields.  When such a rule is found, it is copied, the
    1428                 :            :  * LSM field is re-initialized, and the old rule is replaced with the
    1429                 :            :  * updated rule. */
    1430                 :          0 : int audit_update_lsm_rules(void)
    1431                 :            : {
    1432                 :          0 :         struct audit_krule *r, *n;
    1433                 :          0 :         int i, err = 0;
    1434                 :            : 
    1435                 :            :         /* audit_filter_mutex synchronizes the writers */
    1436                 :          0 :         mutex_lock(&audit_filter_mutex);
    1437                 :            : 
    1438         [ #  # ]:          0 :         for (i = 0; i < AUDIT_NR_FILTERS; i++) {
    1439         [ #  # ]:          0 :                 list_for_each_entry_safe(r, n, &audit_rules_list[i], list) {
    1440                 :          0 :                         int res = update_lsm_rule(r);
    1441         [ #  # ]:          0 :                         if (!err)
    1442                 :          0 :                                 err = res;
    1443                 :            :                 }
    1444                 :            :         }
    1445                 :          0 :         mutex_unlock(&audit_filter_mutex);
    1446                 :            : 
    1447                 :          0 :         return err;
    1448                 :            : }

Generated by: LCOV version 1.14