security/integrity/ima/ima_main.c

   1 /*
   2  * Copyright (C) 2005,2006,2007,2008 IBM Corporation
   3  *
   4  * Authors:
   5  * Reiner Sailer <sailer@watson.ibm.com>
   6  * Serge Hallyn <serue@us.ibm.com>
   7  * Kylene Hall <kylene@us.ibm.com>
   8  * Mimi Zohar <zohar@us.ibm.com>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation, version 2 of the
  13  * License.
  14  *
  15  * File: ima_main.c
  16  *      implements the IMA hooks: ima_bprm_check, ima_file_mmap,
  17  *      and ima_file_check.
  18  */
  19
  20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22 #include <linux/module.h>
  23 #include <linux/file.h>
  24 #include <linux/binfmts.h>
  25 #include <linux/mount.h>
  26 #include <linux/mman.h>
  27 #include <linux/slab.h>
  28 #include <linux/xattr.h>
  29 #include <linux/ima.h>
  30
  31 #include "ima.h"
  32
  33 int ima_initialized;
  34
  35 #ifdef CONFIG_IMA_APPRAISE
  36 int ima_appraise = IMA_APPRAISE_ENFORCE;
  37 #else
  38 int ima_appraise;
  39 #endif
  40
  41 int ima_hash_algo = HASH_ALGO_SHA1;
  42 static int hash_setup_done;
  43
  44 static int __init hash_setup(char *str)
  45 {
  46         struct ima_template_desc *template_desc = ima_template_desc_current();
  47         int i;
  48
  49         if (hash_setup_done)
  50                 return 1;
  51
  52         if (strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) == 0) {
  53                 if (strncmp(str, "sha1", 4) == 0)
  54                         ima_hash_algo = HASH_ALGO_SHA1;
  55                 else if (strncmp(str, "md5", 3) == 0)
  56                         ima_hash_algo = HASH_ALGO_MD5;
  57                 else
  58                         return 1;
  59                 goto out;
  60         }
  61
  62         for (i = 0; i < HASH_ALGO__LAST; i++) {
  63                 if (strcmp(str, hash_algo_name[i]) == 0) {
  64                         ima_hash_algo = i;
  65                         break;
  66                 }
  67         }
  68         if (i == HASH_ALGO__LAST)
  69                 return 1;
  70 out:
  71         hash_setup_done = 1;
  72         return 1;
  73 }
  74 __setup("ima_hash=", hash_setup);
  75
  76 /*
  77  * ima_rdwr_violation_check
  78  *
  79  * Only invalidate the PCR for measured files:
  80  *      - Opening a file for write when already open for read,
  81  *        results in a time of measure, time of use (ToMToU) error.
  82  *      - Opening a file for read when already open for write,
  83  *        could result in a file measurement error.
  84  *
  85  */
  86 static void ima_rdwr_violation_check(struct file *file,
  87                                      struct integrity_iint_cache *iint,
  88                                      int must_measure,
  89                                      char **pathbuf,
  90                                      const char **pathname)
  91 {
  92         struct inode *inode = file_inode(file);
  93         char filename[NAME_MAX];
  94         fmode_t mode = file->f_mode;
  95         bool send_tomtou = false, send_writers = false;
  96
  97         if (mode & FMODE_WRITE) {
  98                 if (atomic_read(&inode->i_readcount) && IS_IMA(inode)) {
  99                         if (!iint)
 100                                 iint = integrity_iint_find(inode);
 101                         /* IMA_MEASURE is set from reader side */
 102                         if (iint && test_bit(IMA_MUST_MEASURE,
 103                                                 &iint->atomic_flags))
 104                                 send_tomtou = true;
 105                 }
 106         } else {
 107                 if (must_measure)
 108                         set_bit(IMA_MUST_MEASURE, &iint->atomic_flags);
 109                 if ((atomic_read(&inode->i_writecount) > 0) && must_measure)
 110                         send_writers = true;
 111         }
 112
 113         if (!send_tomtou && !send_writers)
 114                 return;
 115
 116         *pathname = ima_d_path(&file->f_path, pathbuf, filename);
 117
 118         if (send_tomtou)
 119                 ima_add_violation(file, *pathname, iint,
 120                                   "invalid_pcr", "ToMToU");
 121         if (send_writers)
 122                 ima_add_violation(file, *pathname, iint,
 123                                   "invalid_pcr", "open_writers");
 124 }
 125
 126 static void ima_check_last_writer(struct integrity_iint_cache *iint,
 127                                   struct inode *inode, struct file *file)
 128 {
 129         fmode_t mode = file->f_mode;
 130         bool update;
 131
 132         if (!(mode & FMODE_WRITE))
 133                 return;
 134
 135         mutex_lock(&iint->mutex);
 136         if (atomic_read(&inode->i_writecount) == 1) {
 137                 update = test_and_clear_bit(IMA_UPDATE_XATTR,
 138                                             &iint->atomic_flags);
 139                 if ((iint->version != inode->i_version) ||
 140                     (iint->flags & IMA_NEW_FILE)) {
 141                         iint->flags &= ~(IMA_DONE_MASK | IMA_NEW_FILE);
 142                         iint->measured_pcrs = 0;
 143                         if (update)
 144                                 ima_update_xattr(iint, file);
 145                 }
 146         }
 147         mutex_unlock(&iint->mutex);
 148 }
 149
 150 /**
 151  * ima_file_free - called on __fput()
 152  * @file: pointer to file structure being freed
 153  *
 154  * Flag files that changed, based on i_version
 155  */
 156 void ima_file_free(struct file *file)
 157 {
 158         struct inode *inode = file_inode(file);
 159         struct integrity_iint_cache *iint;
 160
 161         if (!ima_policy_flag || !S_ISREG(inode->i_mode))
 162                 return;
 163
 164         iint = integrity_iint_find(inode);
 165         if (!iint)
 166                 return;
 167
 168         ima_check_last_writer(iint, inode, file);
 169 }
 170
 171 static int process_measurement(struct file *file, char *buf, loff_t size,
 172                                int mask, enum ima_hooks func, int opened)
 173 {
 174         struct inode *inode = file_inode(file);
 175         struct integrity_iint_cache *iint = NULL;
 176         struct ima_template_desc *template_desc;
 177         char *pathbuf = NULL;
 178         char filename[NAME_MAX];
 179         const char *pathname = NULL;
 180         int rc = 0, action, must_appraise = 0;
 181         int pcr = CONFIG_IMA_MEASURE_PCR_IDX;
 182         struct evm_ima_xattr_data *xattr_value = NULL;
 183         int xattr_len = 0;
 184         bool violation_check;
 185         enum hash_algo hash_algo;
 186
 187         if (!ima_policy_flag || !S_ISREG(inode->i_mode))
 188                 return 0;
 189
 190         /* Return an IMA_MEASURE, IMA_APPRAISE, IMA_AUDIT action
 191          * bitmask based on the appraise/audit/measurement policy.
 192          * Included is the appraise submask.
 193          */
 194         action = ima_get_action(inode, mask, func, &pcr);
 195         violation_check = ((func == FILE_CHECK || func == MMAP_CHECK) &&
 196                            (ima_policy_flag & IMA_MEASURE));
 197         if (!action && !violation_check)
 198                 return 0;
 199
 200         must_appraise = action & IMA_APPRAISE;
 201
 202         /*  Is the appraise rule hook specific?  */
 203         if (action & IMA_FILE_APPRAISE)
 204                 func = FILE_CHECK;
 205
 206         inode_lock(inode);
 207
 208         if (action) {
 209                 iint = integrity_inode_get(inode);
 210                 if (!iint)
 211                         rc = -ENOMEM;
 212         }
 213
 214         if (!rc && violation_check)
 215                 ima_rdwr_violation_check(file, iint, action & IMA_MEASURE,
 216                                          &pathbuf, &pathname);
 217
 218         inode_unlock(inode);
 219
 220         if (rc)
 221                 goto out;
 222         if (!action)
 223                 goto out;
 224
 225         mutex_lock(&iint->mutex);
 226
 227         if (test_and_clear_bit(IMA_CHANGE_ATTR, &iint->atomic_flags))
 228                 /* reset appraisal flags if ima_inode_post_setattr was called */
 229                 iint->flags &= ~(IMA_APPRAISE | IMA_APPRAISED |
 230                                  IMA_APPRAISE_SUBMASK | IMA_APPRAISED_SUBMASK |
 231                                  IMA_ACTION_FLAGS);
 232
 233         if (test_and_clear_bit(IMA_CHANGE_XATTR, &iint->atomic_flags))
 234                 /* reset all flags if ima_inode_setxattr was called */
 235                 iint->flags &= ~IMA_DONE_MASK;
 236
 237         /* Determine if already appraised/measured based on bitmask
 238          * (IMA_MEASURE, IMA_MEASURED, IMA_XXXX_APPRAISE, IMA_XXXX_APPRAISED,
 239          *  IMA_AUDIT, IMA_AUDITED)
 240          */
 241         iint->flags |= action;
 242         action &= IMA_DO_MASK;
 243         action &= ~((iint->flags & (IMA_DONE_MASK ^ IMA_MEASURED)) >> 1);
 244
 245         /* If target pcr is already measured, unset IMA_MEASURE action */
 246         if ((action & IMA_MEASURE) && (iint->measured_pcrs & (0x1 << pcr)))
 247                 action ^= IMA_MEASURE;
 248
 249         /* Nothing to do, just return existing appraised status */
 250         if (!action) {
 251                 if (must_appraise)
 252                         rc = ima_get_cache_status(iint, func);
 253                 goto out_locked;
 254         }
 255
 256         template_desc = ima_template_desc_current();
 257         if ((action & IMA_APPRAISE_SUBMASK) ||
 258                     strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) != 0)
 259                 /* read 'security.ima' */
 260                 xattr_len = ima_read_xattr(file_dentry(file), &xattr_value);
 261
 262         hash_algo = ima_get_hash_algo(xattr_value, xattr_len);
 263
 264         rc = ima_collect_measurement(iint, file, buf, size, hash_algo);
 265         if (rc != 0 && rc != -EBADF && rc != -EINVAL)
 266                 goto out_locked;
 267
 268         if (!pathbuf)   /* ima_rdwr_violation possibly pre-fetched */
 269                 pathname = ima_d_path(&file->f_path, &pathbuf, filename);
 270
 271         if (action & IMA_MEASURE)
 272                 ima_store_measurement(iint, file, pathname,
 273                                       xattr_value, xattr_len, pcr);
 274         if (rc == 0 && (action & IMA_APPRAISE_SUBMASK)) {
 275                 inode_lock(inode);
 276                 rc = ima_appraise_measurement(func, iint, file, pathname,
 277                                               xattr_value, xattr_len, opened);
 278                 inode_unlock(inode);
 279         }
 280         if (action & IMA_AUDIT)
 281                 ima_audit_measurement(iint, pathname);
 282
 283         if ((file->f_flags & O_DIRECT) && (iint->flags & IMA_PERMIT_DIRECTIO))
 284                 rc = 0;
 285 out_locked:
 286         if ((mask & MAY_WRITE) && test_bit(IMA_DIGSIG, &iint->atomic_flags) &&
 287              !(iint->flags & IMA_NEW_FILE))
 288                 rc = -EACCES;
 289         mutex_unlock(&iint->mutex);
 290         kfree(xattr_value);
 291 out:
 292         if (pathbuf)
 293                 __putname(pathbuf);
 294         if (must_appraise) {
 295                 if (rc && (ima_appraise & IMA_APPRAISE_ENFORCE))
 296                         return -EACCES;
 297                 if (file->f_mode & FMODE_WRITE)
 298                         set_bit(IMA_UPDATE_XATTR, &iint->atomic_flags);
 299         }
 300         return 0;
 301 }
 302
 303 /**
 304  * ima_file_mmap - based on policy, collect/store measurement.
 305  * @file: pointer to the file to be measured (May be NULL)
 306  * @reqprot: protection requested by the application
 307  * @prot: protection that will be applied by the kernel
 308  * @flags: operational flags
 309  *
 310  * Measure files being mmapped executable based on the ima_must_measure()
 311  * policy decision.
 312  *
 313  * On success return 0.  On integrity appraisal error, assuming the file
 314  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
 315  */
 316 int ima_file_mmap(struct file *file, unsigned long reqprot,
 317                   unsigned long prot, unsigned long flags)
 318 {
 319         if (file && (prot & PROT_EXEC))
 320                 return process_measurement(file, NULL, 0, MAY_EXEC,
 321                                            MMAP_CHECK, 0);
 322         return 0;
 323 }
 324
 325 /**
 326  * ima_bprm_check - based on policy, collect/store measurement.
 327  * @bprm: contains the linux_binprm structure
 328  *
 329  * The OS protects against an executable file, already open for write,
 330  * from being executed in deny_write_access() and an executable file,
 331  * already open for execute, from being modified in get_write_access().
 332  * So we can be certain that what we verify and measure here is actually
 333  * what is being executed.
 334  *
 335  * On success return 0.  On integrity appraisal error, assuming the file
 336  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
 337  */
 338 int ima_bprm_check(struct linux_binprm *bprm)
 339 {
 340         return process_measurement(bprm->file, NULL, 0, MAY_EXEC,
 341                                    BPRM_CHECK, 0);
 342 }
 343
 344 /**
 345  * ima_path_check - based on policy, collect/store measurement.
 346  * @file: pointer to the file to be measured
 347  * @mask: contains MAY_READ, MAY_WRITE, MAY_EXEC or MAY_APPEND
 348  *
 349  * Measure files based on the ima_must_measure() policy decision.
 350  *
 351  * On success return 0.  On integrity appraisal error, assuming the file
 352  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
 353  */
 354 int ima_file_check(struct file *file, int mask, int opened)
 355 {
 356         return process_measurement(file, NULL, 0,
 357                                    mask & (MAY_READ | MAY_WRITE | MAY_EXEC |
 358                                            MAY_APPEND), FILE_CHECK, opened);
 359 }
 360 EXPORT_SYMBOL_GPL(ima_file_check);
 361
 362 /**
 363  * ima_post_path_mknod - mark as a new inode
 364  * @dentry: newly created dentry
 365  *
 366  * Mark files created via the mknodat syscall as new, so that the
 367  * file data can be written later.
 368  */
 369 void ima_post_path_mknod(struct dentry *dentry)
 370 {
 371         struct integrity_iint_cache *iint;
 372         struct inode *inode = dentry->d_inode;
 373         int must_appraise;
 374
 375         must_appraise = ima_must_appraise(inode, MAY_ACCESS, FILE_CHECK);
 376         if (!must_appraise)
 377                 return;
 378
 379         iint = integrity_inode_get(inode);
 380         if (iint)
 381                 iint->flags |= IMA_NEW_FILE;
 382 }
 383
 384 /**
 385  * ima_read_file - pre-measure/appraise hook decision based on policy
 386  * @file: pointer to the file to be measured/appraised/audit
 387  * @read_id: caller identifier
 388  *
 389  * Permit reading a file based on policy. The policy rules are written
 390  * in terms of the policy identifier.  Appraising the integrity of
 391  * a file requires a file descriptor.
 392  *
 393  * For permission return 0, otherwise return -EACCES.
 394  */
 395 int ima_read_file(struct file *file, enum kernel_read_file_id read_id)
 396 {
 397         if (!file && read_id == READING_MODULE) {
 398 #ifndef CONFIG_MODULE_SIG_FORCE
 399                 if ((ima_appraise & IMA_APPRAISE_MODULES) &&
 400                     (ima_appraise & IMA_APPRAISE_ENFORCE))
 401                         return -EACCES; /* INTEGRITY_UNKNOWN */
 402 #endif
 403                 return 0;       /* We rely on module signature checking */
 404         }
 405         return 0;
 406 }
 407
 408 static int read_idmap[READING_MAX_ID] = {
 409         [READING_FIRMWARE] = FIRMWARE_CHECK,
 410         [READING_FIRMWARE_PREALLOC_BUFFER] = FIRMWARE_CHECK,
 411         [READING_MODULE] = MODULE_CHECK,
 412         [READING_KEXEC_IMAGE] = KEXEC_KERNEL_CHECK,
 413         [READING_KEXEC_INITRAMFS] = KEXEC_INITRAMFS_CHECK,
 414         [READING_POLICY] = POLICY_CHECK
 415 };
 416
 417 /**
 418  * ima_post_read_file - in memory collect/appraise/audit measurement
 419  * @file: pointer to the file to be measured/appraised/audit
 420  * @buf: pointer to in memory file contents
 421  * @size: size of in memory file contents
 422  * @read_id: caller identifier
 423  *
 424  * Measure/appraise/audit in memory file based on policy.  Policy rules
 425  * are written in terms of a policy identifier.
 426  *
 427  * On success return 0.  On integrity appraisal error, assuming the file
 428  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
 429  */
 430 int ima_post_read_file(struct file *file, void *buf, loff_t size,
 431                        enum kernel_read_file_id read_id)
 432 {
 433         enum ima_hooks func;
 434
 435         if (!file && read_id == READING_FIRMWARE) {
 436                 if ((ima_appraise & IMA_APPRAISE_FIRMWARE) &&
 437                     (ima_appraise & IMA_APPRAISE_ENFORCE))
 438                         return -EACCES; /* INTEGRITY_UNKNOWN */
 439                 return 0;
 440         }
 441
 442         if (!file && read_id == READING_MODULE) /* MODULE_SIG_FORCE enabled */
 443                 return 0;
 444
 445         if (!file || !buf || size == 0) { /* should never happen */
 446                 if (ima_appraise & IMA_APPRAISE_ENFORCE)
 447                         return -EACCES;
 448                 return 0;
 449         }
 450
 451         func = read_idmap[read_id] ?: FILE_CHECK;
 452         return process_measurement(file, buf, size, MAY_READ, func, 0);
 453 }
 454
 455 static int __init init_ima(void)
 456 {
 457         int error;
 458
 459         ima_init_template_list();
 460         hash_setup(CONFIG_IMA_DEFAULT_HASH);
 461         error = ima_init();
 462
 463         if (error && strcmp(hash_algo_name[ima_hash_algo],
 464                             CONFIG_IMA_DEFAULT_HASH) != 0) {
 465                 pr_info("Allocating %s failed, going to use default hash algorithm %s\n",
 466                         hash_algo_name[ima_hash_algo], CONFIG_IMA_DEFAULT_HASH);
 467                 hash_setup_done = 0;
 468                 hash_setup(CONFIG_IMA_DEFAULT_HASH);
 469                 error = ima_init();
 470         }
 471
 472         if (!error) {
 473                 ima_initialized = 1;
 474                 ima_update_policy_flag();
 475         }
 476         return error;
 477 }
 478
 479 late_initcall(init_ima);        /* Start IMA after the TPM is available */
 480
 481 MODULE_DESCRIPTION("Integrity Measurement Architecture");
 482 MODULE_LICENSE("GPL");