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>
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 ima_event_data *event_data,
41 struct ima_template_entry **entry)
43 struct ima_template_desc *template_desc = ima_template_desc_current();
46 *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
47 sizeof(struct ima_field_data), GFP_NOFS);
51 (*entry)->template_desc = template_desc;
52 for (i = 0; i < template_desc->num_fields; i++) {
53 struct ima_template_field *field = template_desc->fields[i];
56 result = field->field_init(event_data,
57 &((*entry)->template_data[i]));
61 len = (*entry)->template_data[i].len;
62 (*entry)->template_data_len += sizeof(len);
63 (*entry)->template_data_len += len;
67 ima_free_template_entry(*entry);
73 * ima_store_template - store ima template measurements
75 * Calculate the hash of a template entry, add the template entry
76 * to an ordered list of measurement entries maintained inside the kernel,
77 * and also update the aggregate integrity value (maintained inside the
78 * configured TPM PCR) over the hashes of the current list of measurement
81 * Applications retrieve the current kernel-held measurement list through
82 * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
83 * TPM PCR (called quote) can be retrieved using a TPM user space library
84 * and is used to validate the measurement list.
86 * Returns 0 on success, error code otherwise
88 int ima_store_template(struct ima_template_entry *entry,
89 int violation, struct inode *inode,
90 const unsigned char *filename, int pcr)
92 static const char op[] = "add_template_measure";
93 static const char audit_cause[] = "hashing_error";
94 char *template_name = entry->template_desc->name;
97 struct ima_digest_data hdr;
98 char digest[TPM_DIGEST_SIZE];
102 int num_fields = entry->template_desc->num_fields;
104 /* this function uses default algo */
105 hash.hdr.algo = HASH_ALGO_SHA1;
106 result = ima_calc_field_array_hash(&entry->template_data[0],
107 entry->template_desc,
108 num_fields, &hash.hdr);
110 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
112 audit_cause, result, 0);
115 memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
118 result = ima_add_template_entry(entry, violation, op, inode, filename);
123 * ima_add_violation - add violation to measurement list.
125 * Violations are flagged in the measurement list with zero hash values.
126 * By extending the PCR with 0xFF's instead of with zeroes, the PCR
127 * value is invalidated.
129 void ima_add_violation(struct file *file, const unsigned char *filename,
130 struct integrity_iint_cache *iint,
131 const char *op, const char *cause)
133 struct ima_template_entry *entry;
134 struct inode *inode = file_inode(file);
135 struct ima_event_data event_data = {iint, file, filename, NULL, 0,
140 /* can overflow, only indicator */
141 atomic_long_inc(&ima_htable.violations);
143 result = ima_alloc_init_template(&event_data, &entry);
148 result = ima_store_template(entry, violation, inode,
149 filename, CONFIG_IMA_MEASURE_PCR_IDX);
151 ima_free_template_entry(entry);
153 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
154 op, cause, result, 0);
158 * ima_get_action - appraise & measure decision based on policy.
159 * @inode: pointer to inode to measure
160 * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXEC,
162 * @func: caller identifier
163 * @pcr: pointer filled in if matched measure policy sets pcr=
165 * The policy is defined in terms of keypairs:
166 * subj=, obj=, type=, func=, mask=, fsmagic=
167 * subj,obj, and type: are LSM specific.
168 * func: FILE_CHECK | BPRM_CHECK | MMAP_CHECK | MODULE_CHECK
169 * mask: contains the permission mask
172 * Returns IMA_MEASURE, IMA_APPRAISE mask.
175 int ima_get_action(struct inode *inode, int mask, enum ima_hooks func, int *pcr)
177 int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE;
179 flags &= ima_policy_flag;
181 return ima_match_policy(inode, func, mask, flags, pcr);
185 * ima_collect_measurement - collect file measurement
187 * Calculate the file hash, if it doesn't already exist,
188 * storing the measurement and i_version in the iint.
190 * Must be called with iint->mutex held.
192 * Return 0 on success, error code otherwise
194 int ima_collect_measurement(struct integrity_iint_cache *iint,
195 struct file *file, void *buf, loff_t size,
198 const char *audit_cause = "failed";
199 struct inode *inode = file_inode(file);
200 const char *filename = file->f_path.dentry->d_name.name;
206 struct ima_digest_data hdr;
207 char digest[IMA_MAX_DIGEST_SIZE];
210 if (iint->flags & IMA_COLLECTED)
214 * Dectecting file change is based on i_version. On filesystems
215 * which do not support i_version, support is limited to an initial
216 * measurement/appraisal/audit.
218 i_version = file_inode(file)->i_version;
219 hash.hdr.algo = algo;
221 /* Initialize hash digest to 0's in case of failure */
222 memset(&hash.digest, 0, sizeof(hash.digest));
225 result = ima_calc_buffer_hash(buf, size, &hash.hdr);
227 result = ima_calc_file_hash(file, &hash.hdr);
229 if (result && result != -EBADF && result != -EINVAL)
232 length = sizeof(hash.hdr) + hash.hdr.length;
233 tmpbuf = krealloc(iint->ima_hash, length, GFP_NOFS);
239 iint->ima_hash = tmpbuf;
240 memcpy(iint->ima_hash, &hash, length);
241 iint->version = i_version;
243 /* Possibly temporary failure due to type of read (eg. O_DIRECT) */
245 iint->flags |= IMA_COLLECTED;
248 if (file->f_flags & O_DIRECT)
249 audit_cause = "failed(directio)";
251 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
252 filename, "collect_data", audit_cause,
259 * ima_store_measurement - store file measurement
261 * Create an "ima" template and then store the template by calling
262 * ima_store_template.
264 * We only get here if the inode has not already been measured,
265 * but the measurement could already exist:
266 * - multiple copies of the same file on either the same or
267 * different filesystems.
268 * - the inode was previously flushed as well as the iint info,
269 * containing the hashing info.
271 * Must be called with iint->mutex held.
273 void ima_store_measurement(struct integrity_iint_cache *iint,
274 struct file *file, const unsigned char *filename,
275 struct evm_ima_xattr_data *xattr_value,
276 int xattr_len, int pcr)
278 static const char op[] = "add_template_measure";
279 static const char audit_cause[] = "ENOMEM";
280 int result = -ENOMEM;
281 struct inode *inode = file_inode(file);
282 struct ima_template_entry *entry;
283 struct ima_event_data event_data = {iint, file, filename, xattr_value,
287 if (iint->measured_pcrs & (0x1 << pcr))
290 result = ima_alloc_init_template(&event_data, &entry);
292 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
293 op, audit_cause, result, 0);
297 result = ima_store_template(entry, violation, inode, filename, pcr);
298 if ((!result || result == -EEXIST) && !(file->f_flags & O_DIRECT)) {
299 iint->flags |= IMA_MEASURED;
300 iint->measured_pcrs |= (0x1 << pcr);
303 ima_free_template_entry(entry);
306 void ima_audit_measurement(struct integrity_iint_cache *iint,
307 const unsigned char *filename)
309 struct audit_buffer *ab;
310 char hash[(iint->ima_hash->length * 2) + 1];
311 const char *algo_name = hash_algo_name[iint->ima_hash->algo];
312 char algo_hash[sizeof(hash) + strlen(algo_name) + 2];
315 if (iint->flags & IMA_AUDITED)
318 for (i = 0; i < iint->ima_hash->length; i++)
319 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
322 ab = audit_log_start(current->audit_context, GFP_KERNEL,
323 AUDIT_INTEGRITY_RULE);
327 audit_log_format(ab, "file=");
328 audit_log_untrustedstring(ab, filename);
329 audit_log_format(ab, " hash=");
330 snprintf(algo_hash, sizeof(algo_hash), "%s:%s", algo_name, hash);
331 audit_log_untrustedstring(ab, algo_hash);
333 audit_log_task_info(ab, current);
336 iint->flags |= IMA_AUDITED;
340 * ima_d_path - return a pointer to the full pathname
342 * Attempt to return a pointer to the full pathname for use in the
343 * IMA measurement list, IMA audit records, and auditing logs.
345 * On failure, return a pointer to a copy of the filename, not dname.
346 * Returning a pointer to dname, could result in using the pointer
347 * after the memory has been freed.
349 const char *ima_d_path(const struct path *path, char **pathbuf, char *namebuf)
351 char *pathname = NULL;
353 *pathbuf = __getname();
355 pathname = d_absolute_path(path, *pathbuf, PATH_MAX);
356 if (IS_ERR(pathname)) {
364 strlcpy(namebuf, path->dentry->d_name.name, NAME_MAX);