1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2008 IBM Corporation
4 *
5 * Author: Mimi Zohar <zohar@us.ibm.com>
6 *
7 * File: ima_api.c
8 *	Implements must_appraise_or_measure, collect_measurement,
9 *	appraise_measurement, store_measurement and store_template.
10 */
11#include <linux/slab.h>
12#include <linux/file.h>
13#include <linux/fs.h>
14#include <linux/xattr.h>
15#include <linux/evm.h>
16#include <linux/iversion.h>
17
18#include "ima.h"
19
20/*
21 * ima_free_template_entry - free an existing template entry
22 */
23void ima_free_template_entry(struct ima_template_entry *entry)
24{
25	int i;
26
27	for (i = 0; i < entry->template_desc->num_fields; i++)
28		kfree(entry->template_data[i].data);
29
30	kfree(entry->digests);
31	kfree(entry);
32}
33
34/*
35 * ima_alloc_init_template - create and initialize a new template entry
36 */
37int ima_alloc_init_template(struct ima_event_data *event_data,
38			    struct ima_template_entry **entry,
39			    struct ima_template_desc *desc)
40{
41	struct ima_template_desc *template_desc;
42	struct tpm_digest *digests;
43	int i, result = 0;
44
45	if (desc)
46		template_desc = desc;
47	else
48		template_desc = ima_template_desc_current();
49
50	*entry = kzalloc(struct_size(*entry, template_data,
51				     template_desc->num_fields), GFP_NOFS);
52	if (!*entry)
53		return -ENOMEM;
54
55	digests = kcalloc(NR_BANKS(ima_tpm_chip) + ima_extra_slots,
56			  sizeof(*digests), GFP_NOFS);
57	if (!digests) {
58		kfree(*entry);
59		*entry = NULL;
60		return -ENOMEM;
61	}
62
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];
68		u32 len;
69
70		result = field->field_init(event_data,
71					   &((*entry)->template_data[i]));
72		if (result != 0)
73			goto out;
74
75		len = (*entry)->template_data[i].len;
76		(*entry)->template_data_len += sizeof(len);
77		(*entry)->template_data_len += len;
78	}
79	return 0;
80out:
81	ima_free_template_entry(*entry);
82	*entry = NULL;
83	return result;
84}
85
86/*
87 * ima_store_template - store ima template measurements
88 *
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
93 * entries.
94 *
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.
99 *
100 * Returns 0 on success, error code otherwise
101 */
102int ima_store_template(struct ima_template_entry *entry,
103		       int violation, struct inode *inode,
104		       const unsigned char *filename, int pcr)
105{
106	static const char op[] = "add_template_measure";
107	static const char audit_cause[] = "hashing_error";
108	char *template_name = entry->template_desc->name;
109	int result;
110
111	if (!violation) {
112		result = ima_calc_field_array_hash(&entry->template_data[0],
113						   entry);
114		if (result < 0) {
115			integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
116					    template_name, op,
117					    audit_cause, result, 0);
118			return result;
119		}
120	}
121	entry->pcr = pcr;
122	result = ima_add_template_entry(entry, violation, op, inode, filename);
123	return result;
124}
125
126/*
127 * ima_add_violation - add violation to measurement list.
128 *
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.
132 */
133void ima_add_violation(struct file *file, const unsigned char *filename,
134		       struct integrity_iint_cache *iint,
135		       const char *op, const char *cause)
136{
137	struct ima_template_entry *entry;
138	struct inode *inode = file_inode(file);
139	struct ima_event_data event_data = { .iint = iint,
140					     .file = file,
141					     .filename = filename,
142					     .violation = cause };
143	int violation = 1;
144	int result;
145
146	/* can overflow, only indicator */
147	atomic_long_inc(&ima_htable.violations);
148
149	result = ima_alloc_init_template(&event_data, &entry, NULL);
150	if (result < 0) {
151		result = -ENOMEM;
152		goto err_out;
153	}
154	result = ima_store_template(entry, violation, inode,
155				    filename, CONFIG_IMA_MEASURE_PCR_IDX);
156	if (result < 0)
157		ima_free_template_entry(entry);
158err_out:
159	integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
160			    op, cause, result, 0);
161}
162
163/**
164 * ima_get_action - appraise & measure decision based on policy.
165 * @inode: pointer to the inode associated with the object being validated
166 * @cred: pointer to credentials structure to validate
167 * @secid: secid of the task being validated
168 * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXEC,
169 *        MAY_APPEND)
170 * @func: caller identifier
171 * @pcr: pointer filled in if matched measure policy sets pcr=
172 * @template_desc: pointer filled in if matched measure policy sets template=
173 * @keyring: keyring name used to determine the action
174 *
175 * The policy is defined in terms of keypairs:
176 *		subj=, obj=, type=, func=, mask=, fsmagic=
177 *	subj,obj, and type: are LSM specific.
178 *	func: FILE_CHECK | BPRM_CHECK | CREDS_CHECK | MMAP_CHECK | MODULE_CHECK
179 *	| KEXEC_CMDLINE | KEY_CHECK
180 *	mask: contains the permission mask
181 *	fsmagic: hex value
182 *
183 * Returns IMA_MEASURE, IMA_APPRAISE mask.
184 *
185 */
186int ima_get_action(struct inode *inode, const struct cred *cred, u32 secid,
187		   int mask, enum ima_hooks func, int *pcr,
188		   struct ima_template_desc **template_desc,
189		   const char *keyring)
190{
191	int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE | IMA_HASH;
192
193	flags &= ima_policy_flag;
194
195	return ima_match_policy(inode, cred, secid, func, mask, flags, pcr,
196				template_desc, keyring);
197}
198
199/*
200 * ima_collect_measurement - collect file measurement
201 *
202 * Calculate the file hash, if it doesn't already exist,
203 * storing the measurement and i_version in the iint.
204 *
205 * Must be called with iint->mutex held.
206 *
207 * Return 0 on success, error code otherwise
208 */
209int ima_collect_measurement(struct integrity_iint_cache *iint,
210			    struct file *file, void *buf, loff_t size,
211			    enum hash_algo algo, struct modsig *modsig)
212{
213	const char *audit_cause = "failed";
214	struct inode *inode = file_inode(file);
215	struct inode *real_inode = d_real_inode(file_dentry(file));
216	const char *filename = file->f_path.dentry->d_name.name;
217	int result = 0;
218	int length;
219	void *tmpbuf;
220	u64 i_version;
221	struct {
222		struct ima_digest_data hdr;
223		char digest[IMA_MAX_DIGEST_SIZE];
224	} hash;
225
226	/*
227	 * Always collect the modsig, because IMA might have already collected
228	 * the file digest without collecting the modsig in a previous
229	 * measurement rule.
230	 */
231	if (modsig)
232		ima_collect_modsig(modsig, buf, size);
233
234	if (iint->flags & IMA_COLLECTED)
235		goto out;
236
237	/*
238	 * Dectecting file change is based on i_version. On filesystems
239	 * which do not support i_version, support is limited to an initial
240	 * measurement/appraisal/audit.
241	 */
242	i_version = inode_query_iversion(inode);
243	hash.hdr.algo = algo;
244
245	/* Initialize hash digest to 0's in case of failure */
246	memset(&hash.digest, 0, sizeof(hash.digest));
247
248	if (buf)
249		result = ima_calc_buffer_hash(buf, size, &hash.hdr);
250	else
251		result = ima_calc_file_hash(file, &hash.hdr);
252
253	if (result && result != -EBADF && result != -EINVAL)
254		goto out;
255
256	length = sizeof(hash.hdr) + hash.hdr.length;
257	tmpbuf = krealloc(iint->ima_hash, length, GFP_NOFS);
258	if (!tmpbuf) {
259		result = -ENOMEM;
260		goto out;
261	}
262
263	iint->ima_hash = tmpbuf;
264	memcpy(iint->ima_hash, &hash, length);
265	iint->version = i_version;
266	if (real_inode != inode) {
267		iint->real_ino = real_inode->i_ino;
268		iint->real_dev = real_inode->i_sb->s_dev;
269	}
270
271	/* Possibly temporary failure due to type of read (eg. O_DIRECT) */
272	if (!result)
273		iint->flags |= IMA_COLLECTED;
274out:
275	if (result) {
276		if (file->f_flags & O_DIRECT)
277			audit_cause = "failed(directio)";
278
279		integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
280				    filename, "collect_data", audit_cause,
281				    result, 0);
282	}
283	return result;
284}
285
286/*
287 * ima_store_measurement - store file measurement
288 *
289 * Create an "ima" template and then store the template by calling
290 * ima_store_template.
291 *
292 * We only get here if the inode has not already been measured,
293 * but the measurement could already exist:
294 *	- multiple copies of the same file on either the same or
295 *	  different filesystems.
296 *	- the inode was previously flushed as well as the iint info,
297 *	  containing the hashing info.
298 *
299 * Must be called with iint->mutex held.
300 */
301void ima_store_measurement(struct integrity_iint_cache *iint,
302			   struct file *file, const unsigned char *filename,
303			   struct evm_ima_xattr_data *xattr_value,
304			   int xattr_len, const struct modsig *modsig, int pcr,
305			   struct ima_template_desc *template_desc)
306{
307	static const char op[] = "add_template_measure";
308	static const char audit_cause[] = "ENOMEM";
309	int result = -ENOMEM;
310	struct inode *inode = file_inode(file);
311	struct ima_template_entry *entry;
312	struct ima_event_data event_data = { .iint = iint,
313					     .file = file,
314					     .filename = filename,
315					     .xattr_value = xattr_value,
316					     .xattr_len = xattr_len,
317					     .modsig = modsig };
318	int violation = 0;
319
320	/*
321	 * We still need to store the measurement in the case of MODSIG because
322	 * we only have its contents to put in the list at the time of
323	 * appraisal, but a file measurement from earlier might already exist in
324	 * the measurement list.
325	 */
326	if (iint->measured_pcrs & (0x1 << pcr) && !modsig)
327		return;
328
329	result = ima_alloc_init_template(&event_data, &entry, template_desc);
330	if (result < 0) {
331		integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
332				    op, audit_cause, result, 0);
333		return;
334	}
335
336	result = ima_store_template(entry, violation, inode, filename, pcr);
337	if ((!result || result == -EEXIST) && !(file->f_flags & O_DIRECT)) {
338		iint->flags |= IMA_MEASURED;
339		iint->measured_pcrs |= (0x1 << pcr);
340	}
341	if (result < 0)
342		ima_free_template_entry(entry);
343}
344
345void ima_audit_measurement(struct integrity_iint_cache *iint,
346			   const unsigned char *filename)
347{
348	struct audit_buffer *ab;
349	char *hash;
350	const char *algo_name = hash_algo_name[iint->ima_hash->algo];
351	int i;
352
353	if (iint->flags & IMA_AUDITED)
354		return;
355
356	hash = kzalloc((iint->ima_hash->length * 2) + 1, GFP_KERNEL);
357	if (!hash)
358		return;
359
360	for (i = 0; i < iint->ima_hash->length; i++)
361		hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
362	hash[i * 2] = '\0';
363
364	ab = audit_log_start(audit_context(), GFP_KERNEL,
365			     AUDIT_INTEGRITY_RULE);
366	if (!ab)
367		goto out;
368
369	audit_log_format(ab, "file=");
370	audit_log_untrustedstring(ab, filename);
371	audit_log_format(ab, " hash=\"%s:%s\"", algo_name, hash);
372
373	audit_log_task_info(ab);
374	audit_log_end(ab);
375
376	iint->flags |= IMA_AUDITED;
377out:
378	kfree(hash);
379	return;
380}
381
382/*
383 * ima_d_path - return a pointer to the full pathname
384 *
385 * Attempt to return a pointer to the full pathname for use in the
386 * IMA measurement list, IMA audit records, and auditing logs.
387 *
388 * On failure, return a pointer to a copy of the filename, not dname.
389 * Returning a pointer to dname, could result in using the pointer
390 * after the memory has been freed.
391 */
392const char *ima_d_path(const struct path *path, char **pathbuf, char *namebuf)
393{
394	char *pathname = NULL;
395
396	*pathbuf = __getname();
397	if (*pathbuf) {
398		pathname = d_absolute_path(path, *pathbuf, PATH_MAX);
399		if (IS_ERR(pathname)) {
400			__putname(*pathbuf);
401			*pathbuf = NULL;
402			pathname = NULL;
403		}
404	}
405
406	if (!pathname) {
407		strlcpy(namebuf, path->dentry->d_name.name, NAME_MAX);
408		pathname = namebuf;
409	}
410
411	return pathname;
412}
413