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_free_template_entry - free an existing template entry
27 void ima_free_template_entry(struct ima_template_entry *entry)
31 for (i = 0; i < entry->template_desc->num_fields; i++)
32 kfree(entry->template_data[i].data);
38 * ima_alloc_init_template - create and initialize a new template entry
40 int ima_alloc_init_template(struct integrity_iint_cache *iint,
41 struct file *file, const unsigned char *filename,
42 struct evm_ima_xattr_data *xattr_value,
43 int xattr_len, struct ima_template_entry **entry)
45 struct ima_template_desc *template_desc = ima_template_desc_current();
48 *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
49 sizeof(struct ima_field_data), GFP_NOFS);
53 (*entry)->template_desc = template_desc;
54 for (i = 0; i < template_desc->num_fields; i++) {
55 struct ima_template_field *field = template_desc->fields[i];
58 result = field->field_init(iint, file, filename,
59 xattr_value, xattr_len,
60 &((*entry)->template_data[i]));
64 len = (*entry)->template_data[i].len;
65 (*entry)->template_data_len += sizeof(len);
66 (*entry)->template_data_len += len;
70 ima_free_template_entry(*entry);
76 * ima_store_template - store ima template measurements
78 * Calculate the hash of a template entry, add the template entry
79 * to an ordered list of measurement entries maintained inside the kernel,
80 * and also update the aggregate integrity value (maintained inside the
81 * configured TPM PCR) over the hashes of the current list of measurement
84 * Applications retrieve the current kernel-held measurement list through
85 * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
86 * TPM PCR (called quote) can be retrieved using a TPM user space library
87 * and is used to validate the measurement list.
89 * Returns 0 on success, error code otherwise
91 int ima_store_template(struct ima_template_entry *entry,
92 int violation, struct inode *inode,
93 const unsigned char *filename)
95 static const char op[] = "add_template_measure";
96 static const char audit_cause[] = "hashing_error";
97 char *template_name = entry->template_desc->name;
100 struct ima_digest_data hdr;
101 char digest[TPM_DIGEST_SIZE];
105 int num_fields = entry->template_desc->num_fields;
107 /* this function uses default algo */
108 hash.hdr.algo = HASH_ALGO_SHA1;
109 result = ima_calc_field_array_hash(&entry->template_data[0],
110 entry->template_desc,
111 num_fields, &hash.hdr);
113 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
115 audit_cause, result, 0);
118 memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
120 result = ima_add_template_entry(entry, violation, op, inode, filename);
125 * ima_add_violation - add violation to measurement list.
127 * Violations are flagged in the measurement list with zero hash values.
128 * By extending the PCR with 0xFF's instead of with zeroes, the PCR
129 * value is invalidated.
131 void ima_add_violation(struct file *file, const unsigned char *filename,
132 const char *op, const char *cause)
134 struct ima_template_entry *entry;
135 struct inode *inode = file_inode(file);
139 /* can overflow, only indicator */
140 atomic_long_inc(&ima_htable.violations);
142 result = ima_alloc_init_template(NULL, file, filename,
148 result = ima_store_template(entry, violation, inode, filename);
150 ima_free_template_entry(entry);
152 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
153 op, cause, result, 0);
157 * ima_get_action - appraise & measure decision based on policy.
158 * @inode: pointer to inode to measure
159 * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXECUTE)
160 * @function: calling function (FILE_CHECK, BPRM_CHECK, MMAP_CHECK, MODULE_CHECK)
162 * The policy is defined in terms of keypairs:
163 * subj=, obj=, type=, func=, mask=, fsmagic=
164 * subj,obj, and type: are LSM specific.
165 * func: FILE_CHECK | BPRM_CHECK | MMAP_CHECK | MODULE_CHECK
166 * mask: contains the permission mask
169 * Returns IMA_MEASURE, IMA_APPRAISE mask.
172 int ima_get_action(struct inode *inode, int mask, int function)
174 int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE;
177 flags &= ~IMA_APPRAISE;
179 return ima_match_policy(inode, function, mask, flags);
183 * ima_collect_measurement - collect file measurement
185 * Calculate the file hash, if it doesn't already exist,
186 * storing the measurement and i_version in the iint.
188 * Must be called with iint->mutex held.
190 * Return 0 on success, error code otherwise
192 int ima_collect_measurement(struct integrity_iint_cache *iint,
194 struct evm_ima_xattr_data **xattr_value,
197 const char *audit_cause = "failed";
198 struct inode *inode = file_inode(file);
199 const char *filename = file->f_dentry->d_name.name;
202 struct ima_digest_data hdr;
203 char digest[IMA_MAX_DIGEST_SIZE];
207 *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
209 if (!(iint->flags & IMA_COLLECTED)) {
210 u64 i_version = file_inode(file)->i_version;
212 if (file->f_flags & O_DIRECT) {
213 audit_cause = "failed(directio)";
218 /* use default hash algorithm */
219 hash.hdr.algo = ima_hash_algo;
222 ima_get_hash_algo(*xattr_value, *xattr_len, &hash.hdr);
224 result = ima_calc_file_hash(file, &hash.hdr);
226 int length = sizeof(hash.hdr) + hash.hdr.length;
227 void *tmpbuf = krealloc(iint->ima_hash, length,
230 iint->ima_hash = tmpbuf;
231 memcpy(iint->ima_hash, &hash, length);
232 iint->version = i_version;
233 iint->flags |= IMA_COLLECTED;
240 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
241 filename, "collect_data", audit_cause,
247 * ima_store_measurement - store file measurement
249 * Create an "ima" template and then store the template by calling
250 * ima_store_template.
252 * We only get here if the inode has not already been measured,
253 * but the measurement could already exist:
254 * - multiple copies of the same file on either the same or
255 * different filesystems.
256 * - the inode was previously flushed as well as the iint info,
257 * containing the hashing info.
259 * Must be called with iint->mutex held.
261 void ima_store_measurement(struct integrity_iint_cache *iint,
262 struct file *file, const unsigned char *filename,
263 struct evm_ima_xattr_data *xattr_value,
266 static const char op[] = "add_template_measure";
267 static const char audit_cause[] = "ENOMEM";
268 int result = -ENOMEM;
269 struct inode *inode = file_inode(file);
270 struct ima_template_entry *entry;
273 if (iint->flags & IMA_MEASURED)
276 result = ima_alloc_init_template(iint, file, filename,
277 xattr_value, xattr_len, &entry);
279 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
280 op, audit_cause, result, 0);
284 result = ima_store_template(entry, violation, inode, filename);
285 if (!result || result == -EEXIST)
286 iint->flags |= IMA_MEASURED;
288 ima_free_template_entry(entry);
291 void ima_audit_measurement(struct integrity_iint_cache *iint,
292 const unsigned char *filename)
294 struct audit_buffer *ab;
295 char hash[(iint->ima_hash->length * 2) + 1];
296 const char *algo_name = hash_algo_name[iint->ima_hash->algo];
297 char algo_hash[sizeof(hash) + strlen(algo_name) + 2];
300 if (iint->flags & IMA_AUDITED)
303 for (i = 0; i < iint->ima_hash->length; i++)
304 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
307 ab = audit_log_start(current->audit_context, GFP_KERNEL,
308 AUDIT_INTEGRITY_RULE);
312 audit_log_format(ab, "file=");
313 audit_log_untrustedstring(ab, filename);
314 audit_log_format(ab, " hash=");
315 snprintf(algo_hash, sizeof(algo_hash), "%s:%s", algo_name, hash);
316 audit_log_untrustedstring(ab, algo_hash);
318 audit_log_task_info(ab, current);
321 iint->flags |= IMA_AUDITED;
324 const char *ima_d_path(struct path *path, char **pathbuf)
326 char *pathname = NULL;
328 *pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
330 pathname = d_absolute_path(path, *pathbuf, PATH_MAX);
331 if (IS_ERR(pathname)) {
337 return pathname ?: (const char *)path->dentry->d_name.name;