2 * Copyright (C) 2008 IBM Corporation
4 * Author: Mimi Zohar <zohar@us.ibm.com>
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
12 * Implements must_appraise_or_measure, collect_measurement,
13 * appraise_measurement, store_measurement and store_template.
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/file.h>
19 #include <linux/xattr.h>
20 #include <linux/evm.h>
21 #include <crypto/hash_info.h>
25 * ima_alloc_init_template - create and initialize a new template entry
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)
32 struct ima_template_desc *template_desc = ima_template_desc_current();
35 *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
36 sizeof(struct ima_field_data), GFP_NOFS);
40 for (i = 0; i < template_desc->num_fields; i++) {
41 struct ima_template_field *field = template_desc->fields[i];
44 result = field->field_init(iint, file, filename,
45 xattr_value, xattr_len,
46 &((*entry)->template_data[i]));
50 len = (*entry)->template_data[i].len;
51 (*entry)->template_data_len += sizeof(len);
52 (*entry)->template_data_len += len;
54 (*entry)->template_desc = template_desc;
63 * ima_store_template - store ima template measurements
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
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.
76 * Returns 0 on success, error code otherwise
78 int ima_store_template(struct ima_template_entry *entry,
79 int violation, struct inode *inode,
80 const unsigned char *filename)
82 const char *op = "add_template_measure";
83 const char *audit_cause = "hashing_error";
84 char *template_name = entry->template_desc->name;
87 struct ima_digest_data hdr;
88 char digest[TPM_DIGEST_SIZE];
92 int num_fields = entry->template_desc->num_fields;
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);
99 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
101 audit_cause, result, 0);
104 memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
106 result = ima_add_template_entry(entry, violation, op, inode, filename);
111 * ima_add_violation - add violation to measurement list.
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.
117 void ima_add_violation(struct file *file, const unsigned char *filename,
118 const char *op, const char *cause)
120 struct ima_template_entry *entry;
121 struct inode *inode = file->f_dentry->d_inode;
125 /* can overflow, only indicator */
126 atomic_long_inc(&ima_htable.violations);
128 result = ima_alloc_init_template(NULL, file, filename,
134 result = ima_store_template(entry, violation, inode, filename);
138 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
139 op, cause, result, 0);
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)
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
155 * Returns IMA_MEASURE, IMA_APPRAISE mask.
158 int ima_get_action(struct inode *inode, int mask, int function)
160 int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE;
163 flags &= ~IMA_APPRAISE;
165 return ima_match_policy(inode, function, mask, flags);
168 int ima_must_measure(struct inode *inode, int mask, int function)
170 return ima_match_policy(inode, function, mask, IMA_MEASURE);
174 * ima_collect_measurement - collect file measurement
176 * Calculate the file hash, if it doesn't already exist,
177 * storing the measurement and i_version in the iint.
179 * Must be called with iint->mutex held.
181 * Return 0 on success, error code otherwise
183 int ima_collect_measurement(struct integrity_iint_cache *iint,
185 struct evm_ima_xattr_data **xattr_value,
188 struct inode *inode = file_inode(file);
189 const char *filename = file->f_dentry->d_name.name;
192 struct ima_digest_data hdr;
193 char digest[IMA_MAX_DIGEST_SIZE];
197 *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
199 if (!(iint->flags & IMA_COLLECTED)) {
200 u64 i_version = file_inode(file)->i_version;
202 /* use default hash algorithm */
203 hash.hdr.algo = ima_hash_algo;
206 ima_get_hash_algo(*xattr_value, *xattr_len, &hash.hdr);
208 result = ima_calc_file_hash(file, &hash.hdr);
210 int length = sizeof(hash.hdr) + hash.hdr.length;
211 void *tmpbuf = krealloc(iint->ima_hash, length,
214 iint->ima_hash = tmpbuf;
215 memcpy(iint->ima_hash, &hash, length);
216 iint->version = i_version;
217 iint->flags |= IMA_COLLECTED;
223 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
224 filename, "collect_data", "failed",
230 * ima_store_measurement - store file measurement
232 * Create an "ima" template and then store the template by calling
233 * ima_store_template.
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.
242 * Must be called with iint->mutex held.
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,
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;
256 if (iint->flags & IMA_MEASURED)
259 result = ima_alloc_init_template(iint, file, filename,
260 xattr_value, xattr_len, &entry);
262 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
263 op, audit_cause, result, 0);
267 result = ima_store_template(entry, violation, inode, filename);
268 if (!result || result == -EEXIST)
269 iint->flags |= IMA_MEASURED;
274 void ima_audit_measurement(struct integrity_iint_cache *iint,
275 const unsigned char *filename)
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];
283 if (iint->flags & IMA_AUDITED)
286 for (i = 0; i < iint->ima_hash->length; i++)
287 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
290 ab = audit_log_start(current->audit_context, GFP_KERNEL,
291 AUDIT_INTEGRITY_RULE);
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);
301 audit_log_task_info(ab, current);
304 iint->flags |= IMA_AUDITED;
307 const char *ima_d_path(struct path *path, char **pathbuf)
309 char *pathname = NULL;
311 /* We will allow 11 spaces for ' (deleted)' to be appended */
312 *pathbuf = kmalloc(PATH_MAX + 11, GFP_KERNEL);
314 pathname = d_path(path, *pathbuf, PATH_MAX + 11);
315 if (IS_ERR(pathname)) {