1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2008 IBM Corporation
5 * Author: Mimi Zohar <zohar@us.ibm.com>
8 * Implements must_appraise_or_measure, collect_measurement,
9 * appraise_measurement, store_measurement and store_template.
11 #include <linux/slab.h>
12 #include <linux/file.h>
14 #include <linux/xattr.h>
15 #include <linux/evm.h>
16 #include <linux/iversion.h>
21 * ima_free_template_entry - free an existing template entry
23 void ima_free_template_entry(struct ima_template_entry *entry)
27 for (i = 0; i < entry->template_desc->num_fields; i++)
28 kfree(entry->template_data[i].data);
30 kfree(entry->digests);
35 * ima_alloc_init_template - create and initialize a new template entry
37 int ima_alloc_init_template(struct ima_event_data *event_data,
38 struct ima_template_entry **entry,
39 struct ima_template_desc *desc)
41 struct ima_template_desc *template_desc;
42 struct tpm_digest *digests;
48 template_desc = ima_template_desc_current();
50 *entry = kzalloc(struct_size(*entry, template_data,
51 template_desc->num_fields), GFP_NOFS);
55 digests = kcalloc(NR_BANKS(ima_tpm_chip) + ima_extra_slots,
56 sizeof(*digests), GFP_NOFS);
63 (*entry)->digests = digests;
64 (*entry)->template_desc = template_desc;
65 for (i = 0; i < template_desc->num_fields; i++) {
66 const struct ima_template_field *field =
67 template_desc->fields[i];
70 result = field->field_init(event_data,
71 &((*entry)->template_data[i]));
75 len = (*entry)->template_data[i].len;
76 (*entry)->template_data_len += sizeof(len);
77 (*entry)->template_data_len += len;
81 ima_free_template_entry(*entry);
87 * ima_store_template - store ima template measurements
89 * Calculate the hash of a template entry, add the template entry
90 * to an ordered list of measurement entries maintained inside the kernel,
91 * and also update the aggregate integrity value (maintained inside the
92 * configured TPM PCR) over the hashes of the current list of measurement
95 * Applications retrieve the current kernel-held measurement list through
96 * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
97 * TPM PCR (called quote) can be retrieved using a TPM user space library
98 * and is used to validate the measurement list.
100 * Returns 0 on success, error code otherwise
102 int ima_store_template(struct ima_template_entry *entry,
103 int violation, struct inode *inode,
104 const unsigned char *filename, int pcr)
106 static const char op[] = "add_template_measure";
107 static const char audit_cause[] = "hashing_error";
108 char *template_name = entry->template_desc->name;
112 result = ima_calc_field_array_hash(&entry->template_data[0],
115 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
117 audit_cause, result, 0);
122 result = ima_add_template_entry(entry, violation, op, inode, filename);
127 * ima_add_violation - add violation to measurement list.
129 * Violations are flagged in the measurement list with zero hash values.
130 * By extending the PCR with 0xFF's instead of with zeroes, the PCR
131 * value is invalidated.
133 void ima_add_violation(struct file *file, const unsigned char *filename,
134 struct integrity_iint_cache *iint,
135 const char *op, const char *cause)
137 struct ima_template_entry *entry;
138 struct inode *inode = file_inode(file);
139 struct ima_event_data event_data = { .iint = iint,
141 .filename = filename,
142 .violation = cause };
146 /* can overflow, only indicator */
147 atomic_long_inc(&ima_htable.violations);
149 result = ima_alloc_init_template(&event_data, &entry, NULL);
154 result = ima_store_template(entry, violation, inode,
155 filename, CONFIG_IMA_MEASURE_PCR_IDX);
157 ima_free_template_entry(entry);
159 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
160 op, cause, result, 0);
164 * ima_get_action - appraise & measure decision based on policy.
165 * @mnt_userns: user namespace of the mount the inode was found from
166 * @inode: pointer to the inode associated with the object being validated
167 * @cred: pointer to credentials structure to validate
168 * @secid: secid of the task being validated
169 * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXEC,
171 * @func: caller identifier
172 * @pcr: pointer filled in if matched measure policy sets pcr=
173 * @template_desc: pointer filled in if matched measure policy sets template=
174 * @func_data: func specific data, may be NULL
175 * @allowed_algos: allowlist of hash algorithms for the IMA xattr
177 * The policy is defined in terms of keypairs:
178 * subj=, obj=, type=, func=, mask=, fsmagic=
179 * subj,obj, and type: are LSM specific.
180 * func: FILE_CHECK | BPRM_CHECK | CREDS_CHECK | MMAP_CHECK | MODULE_CHECK
181 * | KEXEC_CMDLINE | KEY_CHECK | CRITICAL_DATA
182 * mask: contains the permission mask
185 * Returns IMA_MEASURE, IMA_APPRAISE mask.
188 int ima_get_action(struct user_namespace *mnt_userns, struct inode *inode,
189 const struct cred *cred, u32 secid, int mask,
190 enum ima_hooks func, int *pcr,
191 struct ima_template_desc **template_desc,
192 const char *func_data, unsigned int *allowed_algos)
194 int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE | IMA_HASH;
196 flags &= ima_policy_flag;
198 return ima_match_policy(mnt_userns, inode, cred, secid, func, mask,
199 flags, pcr, template_desc, func_data,
204 * ima_collect_measurement - collect file measurement
206 * Calculate the file hash, if it doesn't already exist,
207 * storing the measurement and i_version in the iint.
209 * Must be called with iint->mutex held.
211 * Return 0 on success, error code otherwise
213 int ima_collect_measurement(struct integrity_iint_cache *iint,
214 struct file *file, void *buf, loff_t size,
215 enum hash_algo algo, struct modsig *modsig)
217 const char *audit_cause = "failed";
218 struct inode *inode = file_inode(file);
219 const char *filename = file->f_path.dentry->d_name.name;
225 struct ima_digest_data hdr;
226 char digest[IMA_MAX_DIGEST_SIZE];
230 * Always collect the modsig, because IMA might have already collected
231 * the file digest without collecting the modsig in a previous
235 ima_collect_modsig(modsig, buf, size);
237 if (iint->flags & IMA_COLLECTED)
241 * Dectecting file change is based on i_version. On filesystems
242 * which do not support i_version, support is limited to an initial
243 * measurement/appraisal/audit.
245 i_version = inode_query_iversion(inode);
246 hash.hdr.algo = algo;
248 /* Initialize hash digest to 0's in case of failure */
249 memset(&hash.digest, 0, sizeof(hash.digest));
252 result = ima_calc_buffer_hash(buf, size, &hash.hdr);
254 result = ima_calc_file_hash(file, &hash.hdr);
256 if (result && result != -EBADF && result != -EINVAL)
259 length = sizeof(hash.hdr) + hash.hdr.length;
260 tmpbuf = krealloc(iint->ima_hash, length, GFP_NOFS);
266 iint->ima_hash = tmpbuf;
267 memcpy(iint->ima_hash, &hash, length);
268 iint->version = i_version;
270 /* Possibly temporary failure due to type of read (eg. O_DIRECT) */
272 iint->flags |= IMA_COLLECTED;
275 if (file->f_flags & O_DIRECT)
276 audit_cause = "failed(directio)";
278 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
279 filename, "collect_data", audit_cause,
286 * ima_store_measurement - store file measurement
288 * Create an "ima" template and then store the template by calling
289 * ima_store_template.
291 * We only get here if the inode has not already been measured,
292 * but the measurement could already exist:
293 * - multiple copies of the same file on either the same or
294 * different filesystems.
295 * - the inode was previously flushed as well as the iint info,
296 * containing the hashing info.
298 * Must be called with iint->mutex held.
300 void ima_store_measurement(struct integrity_iint_cache *iint,
301 struct file *file, const unsigned char *filename,
302 struct evm_ima_xattr_data *xattr_value,
303 int xattr_len, const struct modsig *modsig, int pcr,
304 struct ima_template_desc *template_desc)
306 static const char op[] = "add_template_measure";
307 static const char audit_cause[] = "ENOMEM";
308 int result = -ENOMEM;
309 struct inode *inode = file_inode(file);
310 struct ima_template_entry *entry;
311 struct ima_event_data event_data = { .iint = iint,
313 .filename = filename,
314 .xattr_value = xattr_value,
315 .xattr_len = xattr_len,
320 * We still need to store the measurement in the case of MODSIG because
321 * we only have its contents to put in the list at the time of
322 * appraisal, but a file measurement from earlier might already exist in
323 * the measurement list.
325 if (iint->measured_pcrs & (0x1 << pcr) && !modsig)
328 result = ima_alloc_init_template(&event_data, &entry, template_desc);
330 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
331 op, audit_cause, result, 0);
335 result = ima_store_template(entry, violation, inode, filename, pcr);
336 if ((!result || result == -EEXIST) && !(file->f_flags & O_DIRECT)) {
337 iint->flags |= IMA_MEASURED;
338 iint->measured_pcrs |= (0x1 << pcr);
341 ima_free_template_entry(entry);
344 void ima_audit_measurement(struct integrity_iint_cache *iint,
345 const unsigned char *filename)
347 struct audit_buffer *ab;
349 const char *algo_name = hash_algo_name[iint->ima_hash->algo];
352 if (iint->flags & IMA_AUDITED)
355 hash = kzalloc((iint->ima_hash->length * 2) + 1, GFP_KERNEL);
359 for (i = 0; i < iint->ima_hash->length; i++)
360 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
363 ab = audit_log_start(audit_context(), GFP_KERNEL,
364 AUDIT_INTEGRITY_RULE);
368 audit_log_format(ab, "file=");
369 audit_log_untrustedstring(ab, filename);
370 audit_log_format(ab, " hash=\"%s:%s\"", algo_name, hash);
372 audit_log_task_info(ab);
375 iint->flags |= IMA_AUDITED;
382 * ima_d_path - return a pointer to the full pathname
384 * Attempt to return a pointer to the full pathname for use in the
385 * IMA measurement list, IMA audit records, and auditing logs.
387 * On failure, return a pointer to a copy of the filename, not dname.
388 * Returning a pointer to dname, could result in using the pointer
389 * after the memory has been freed.
391 const char *ima_d_path(const struct path *path, char **pathbuf, char *namebuf)
393 char *pathname = NULL;
395 *pathbuf = __getname();
397 pathname = d_absolute_path(path, *pathbuf, PATH_MAX);
398 if (IS_ERR(pathname)) {
406 strscpy(namebuf, path->dentry->d_name.name, NAME_MAX);