security/integrity/ima/ima_api.c

   1 /*
   2  * Copyright (C) 2008 IBM Corporation
   3  *
   4  * Author: Mimi Zohar <zohar@us.ibm.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation, version 2 of the
   9  * License.
  10  *
  11  * File: ima_api.c
  12  *      Implements must_appraise_or_measure, collect_measurement,
  13  *      appraise_measurement, store_measurement and store_template.
  14  */
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <linux/file.h>
  18 #include <linux/fs.h>
  19 #include <linux/xattr.h>
  20 #include <linux/evm.h>
  21 #include <crypto/hash_info.h>
  22 #include "ima.h"
  23
  24 /*
  25  * ima_alloc_init_template - create and initialize a new template entry
  26  */
  27 int ima_alloc_init_template(struct integrity_iint_cache *iint,
  28                             struct file *file, const unsigned char *filename,
  29                             struct evm_ima_xattr_data *xattr_value,
  30                             int xattr_len, struct ima_template_entry **entry)
  31 {
  32         struct ima_template_desc *template_desc = ima_template_desc_current();
  33         int i, result = 0;
  34
  35         *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
  36                          sizeof(struct ima_field_data), GFP_NOFS);
  37         if (!*entry)
  38                 return -ENOMEM;
  39
  40         for (i = 0; i < template_desc->num_fields; i++) {
  41                 struct ima_template_field *field = template_desc->fields[i];
  42                 u32 len;
  43
  44                 result = field->field_init(iint, file, filename,
  45                                            xattr_value, xattr_len,
  46                                            &((*entry)->template_data[i]));
  47                 if (result != 0)
  48                         goto out;
  49
  50                 len = (*entry)->template_data[i].len;
  51                 (*entry)->template_data_len += sizeof(len);
  52                 (*entry)->template_data_len += len;
  53         }
  54         (*entry)->template_desc = template_desc;
  55         return 0;
  56 out:
  57         kfree(*entry);
  58         *entry = NULL;
  59         return result;
  60 }
  61
  62 /*
  63  * ima_store_template - store ima template measurements
  64  *
  65  * Calculate the hash of a template entry, add the template entry
  66  * to an ordered list of measurement entries maintained inside the kernel,
  67  * and also update the aggregate integrity value (maintained inside the
  68  * configured TPM PCR) over the hashes of the current list of measurement
  69  * entries.
  70  *
  71  * Applications retrieve the current kernel-held measurement list through
  72  * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
  73  * TPM PCR (called quote) can be retrieved using a TPM user space library
  74  * and is used to validate the measurement list.
  75  *
  76  * Returns 0 on success, error code otherwise
  77  */
  78 int ima_store_template(struct ima_template_entry *entry,
  79                        int violation, struct inode *inode,
  80                        const unsigned char *filename)
  81 {
  82         const char *op = "add_template_measure";
  83         const char *audit_cause = "hashing_error";
  84         char *template_name = entry->template_desc->name;
  85         int result;
  86         struct {
  87                 struct ima_digest_data hdr;
  88                 char digest[TPM_DIGEST_SIZE];
  89         } hash;
  90
  91         if (!violation) {
  92                 int num_fields = entry->template_desc->num_fields;
  93
  94                 /* this function uses default algo */
  95                 hash.hdr.algo = HASH_ALGO_SHA1;
  96                 result = ima_calc_field_array_hash(&entry->template_data[0],
  97                                                    num_fields, &hash.hdr);
  98                 if (result < 0) {
  99                         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
 100                                             template_name, op,
 101                                             audit_cause, result, 0);
 102                         return result;
 103                 }
 104                 memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
 105         }
 106         result = ima_add_template_entry(entry, violation, op, inode, filename);
 107         return result;
 108 }
 109
 110 /*
 111  * ima_add_violation - add violation to measurement list.
 112  *
 113  * Violations are flagged in the measurement list with zero hash values.
 114  * By extending the PCR with 0xFF's instead of with zeroes, the PCR
 115  * value is invalidated.
 116  */
 117 void ima_add_violation(struct file *file, const unsigned char *filename,
 118                        const char *op, const char *cause)
 119 {
 120         struct ima_template_entry *entry;
 121         struct inode *inode = file->f_dentry->d_inode;
 122         int violation = 1;
 123         int result;
 124
 125         /* can overflow, only indicator */
 126         atomic_long_inc(&ima_htable.violations);
 127
 128         result = ima_alloc_init_template(NULL, file, filename,
 129                                          NULL, 0, &entry);
 130         if (result < 0) {
 131                 result = -ENOMEM;
 132                 goto err_out;
 133         }
 134         result = ima_store_template(entry, violation, inode, filename);
 135         if (result < 0)
 136                 kfree(entry);
 137 err_out:
 138         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
 139                             op, cause, result, 0);
 140 }
 141
 142 /**
 143  * ima_get_action - appraise & measure decision based on policy.
 144  * @inode: pointer to inode to measure
 145  * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXECUTE)
 146  * @function: calling function (FILE_CHECK, BPRM_CHECK, MMAP_CHECK, MODULE_CHECK)
 147  *
 148  * The policy is defined in terms of keypairs:
 149  *              subj=, obj=, type=, func=, mask=, fsmagic=
 150  *      subj,obj, and type: are LSM specific.
 151  *      func: FILE_CHECK | BPRM_CHECK | MMAP_CHECK | MODULE_CHECK
 152  *      mask: contains the permission mask
 153  *      fsmagic: hex value
 154  *
 155  * Returns IMA_MEASURE, IMA_APPRAISE mask.
 156  *
 157  */
 158 int ima_get_action(struct inode *inode, int mask, int function)
 159 {
 160         int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE;
 161
 162         if (!ima_appraise)
 163                 flags &= ~IMA_APPRAISE;
 164
 165         return ima_match_policy(inode, function, mask, flags);
 166 }
 167
 168 int ima_must_measure(struct inode *inode, int mask, int function)
 169 {
 170         return ima_match_policy(inode, function, mask, IMA_MEASURE);
 171 }
 172
 173 /*
 174  * ima_collect_measurement - collect file measurement
 175  *
 176  * Calculate the file hash, if it doesn't already exist,
 177  * storing the measurement and i_version in the iint.
 178  *
 179  * Must be called with iint->mutex held.
 180  *
 181  * Return 0 on success, error code otherwise
 182  */
 183 int ima_collect_measurement(struct integrity_iint_cache *iint,
 184                             struct file *file,
 185                             struct evm_ima_xattr_data **xattr_value,
 186                             int *xattr_len)
 187 {
 188         struct inode *inode = file_inode(file);
 189         const char *filename = file->f_dentry->d_name.name;
 190         int result = 0;
 191         struct {
 192                 struct ima_digest_data hdr;
 193                 char digest[IMA_MAX_DIGEST_SIZE];
 194         } hash;
 195
 196         if (xattr_value)
 197                 *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
 198
 199         if (!(iint->flags & IMA_COLLECTED)) {
 200                 u64 i_version = file_inode(file)->i_version;
 201
 202                 /* use default hash algorithm */
 203                 hash.hdr.algo = ima_hash_algo;
 204
 205                 if (xattr_value)
 206                         ima_get_hash_algo(*xattr_value, *xattr_len, &hash.hdr);
 207
 208                 result = ima_calc_file_hash(file, &hash.hdr);
 209                 if (!result) {
 210                         int length = sizeof(hash.hdr) + hash.hdr.length;
 211                         void *tmpbuf = krealloc(iint->ima_hash, length,
 212                                                 GFP_NOFS);
 213                         if (tmpbuf) {
 214                                 iint->ima_hash = tmpbuf;
 215                                 memcpy(iint->ima_hash, &hash, length);
 216                                 iint->version = i_version;
 217                                 iint->flags |= IMA_COLLECTED;
 218                         } else
 219                                 result = -ENOMEM;
 220                 }
 221         }
 222         if (result)
 223                 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
 224                                     filename, "collect_data", "failed",
 225                                     result, 0);
 226         return result;
 227 }
 228
 229 /*
 230  * ima_store_measurement - store file measurement
 231  *
 232  * Create an "ima" template and then store the template by calling
 233  * ima_store_template.
 234  *
 235  * We only get here if the inode has not already been measured,
 236  * but the measurement could already exist:
 237  *      - multiple copies of the same file on either the same or
 238  *        different filesystems.
 239  *      - the inode was previously flushed as well as the iint info,
 240  *        containing the hashing info.
 241  *
 242  * Must be called with iint->mutex held.
 243  */
 244 void ima_store_measurement(struct integrity_iint_cache *iint,
 245                            struct file *file, const unsigned char *filename,
 246                            struct evm_ima_xattr_data *xattr_value,
 247                            int xattr_len)
 248 {
 249         const char *op = "add_template_measure";
 250         const char *audit_cause = "ENOMEM";
 251         int result = -ENOMEM;
 252         struct inode *inode = file_inode(file);
 253         struct ima_template_entry *entry;
 254         int violation = 0;
 255
 256         if (iint->flags & IMA_MEASURED)
 257                 return;
 258
 259         result = ima_alloc_init_template(iint, file, filename,
 260                                          xattr_value, xattr_len, &entry);
 261         if (result < 0) {
 262                 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
 263                                     op, audit_cause, result, 0);
 264                 return;
 265         }
 266
 267         result = ima_store_template(entry, violation, inode, filename);
 268         if (!result || result == -EEXIST)
 269                 iint->flags |= IMA_MEASURED;
 270         if (result < 0)
 271                 kfree(entry);
 272 }
 273
 274 void ima_audit_measurement(struct integrity_iint_cache *iint,
 275                            const unsigned char *filename)
 276 {
 277         struct audit_buffer *ab;
 278         char hash[(iint->ima_hash->length * 2) + 1];
 279         const char *algo_name = hash_algo_name[iint->ima_hash->algo];
 280         char algo_hash[sizeof(hash) + strlen(algo_name) + 2];
 281         int i;
 282
 283         if (iint->flags & IMA_AUDITED)
 284                 return;
 285
 286         for (i = 0; i < iint->ima_hash->length; i++)
 287                 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
 288         hash[i * 2] = '\0';
 289
 290         ab = audit_log_start(current->audit_context, GFP_KERNEL,
 291                              AUDIT_INTEGRITY_RULE);
 292         if (!ab)
 293                 return;
 294
 295         audit_log_format(ab, "file=");
 296         audit_log_untrustedstring(ab, filename);
 297         audit_log_format(ab, " hash=");
 298         snprintf(algo_hash, sizeof(algo_hash), "%s:%s", algo_name, hash);
 299         audit_log_untrustedstring(ab, algo_hash);
 300
 301         audit_log_task_info(ab, current);
 302         audit_log_end(ab);
 303
 304         iint->flags |= IMA_AUDITED;
 305 }
 306
 307 const char *ima_d_path(struct path *path, char **pathbuf)
 308 {
 309         char *pathname = NULL;
 310
 311         /* We will allow 11 spaces for ' (deleted)' to be appended */
 312         *pathbuf = kmalloc(PATH_MAX + 11, GFP_KERNEL);
 313         if (*pathbuf) {
 314                 pathname = d_path(path, *pathbuf, PATH_MAX + 11);
 315                 if (IS_ERR(pathname)) {
 316                         kfree(*pathbuf);
 317                         *pathbuf = NULL;
 318                         pathname = NULL;
 319                 }
 320         }
 321         return pathname;
 322 }