1 /*
2  * Copyright (C) 2005,2006,2007,2008 IBM Corporation
3  *
4  * Authors:
5  * Reiner Sailer <sailer@watson.ibm.com>
6  * Serge Hallyn <serue@us.ibm.com>
7  * Kylene Hall <kylene@us.ibm.com>
8  * Mimi Zohar <zohar@us.ibm.com>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation, version 2 of the
13  * License.
14  *
15  * File: ima_main.c
16  *	implements the IMA hooks: ima_bprm_check, ima_file_mmap,
17  *	and ima_file_check.
18  */
19 #include <linux/module.h>
20 #include <linux/file.h>
21 #include <linux/binfmts.h>
22 #include <linux/mount.h>
23 #include <linux/mman.h>
24 #include <linux/slab.h>
25 #include <linux/xattr.h>
26 #include <linux/ima.h>
27 #include <crypto/hash_info.h>
28 
29 #include "ima.h"
30 
31 int ima_initialized;
32 
33 #ifdef CONFIG_IMA_APPRAISE
34 int ima_appraise = IMA_APPRAISE_ENFORCE;
35 #else
36 int ima_appraise;
37 #endif
38 
39 int ima_hash_algo = HASH_ALGO_SHA1;
40 static int hash_setup_done;
41 
42 static int __init hash_setup(char *str)
43 {
44 	struct ima_template_desc *template_desc = ima_template_desc_current();
45 	int i;
46 
47 	if (hash_setup_done)
48 		return 1;
49 
50 	if (strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) == 0) {
51 		if (strncmp(str, "sha1", 4) == 0)
52 			ima_hash_algo = HASH_ALGO_SHA1;
53 		else if (strncmp(str, "md5", 3) == 0)
54 			ima_hash_algo = HASH_ALGO_MD5;
55 		goto out;
56 	}
57 
58 	for (i = 0; i < HASH_ALGO__LAST; i++) {
59 		if (strcmp(str, hash_algo_name[i]) == 0) {
60 			ima_hash_algo = i;
61 			break;
62 		}
63 	}
64 out:
65 	hash_setup_done = 1;
66 	return 1;
67 }
68 __setup("ima_hash=", hash_setup);
69 
70 /*
71  * ima_rdwr_violation_check
72  *
73  * Only invalidate the PCR for measured files:
74  *	- Opening a file for write when already open for read,
75  *	  results in a time of measure, time of use (ToMToU) error.
76  *	- Opening a file for read when already open for write,
77  *	  could result in a file measurement error.
78  *
79  */
80 static void ima_rdwr_violation_check(struct file *file,
81 				     struct integrity_iint_cache *iint,
82 				     int must_measure,
83 				     char **pathbuf,
84 				     const char **pathname)
85 {
86 	struct inode *inode = file_inode(file);
87 	fmode_t mode = file->f_mode;
88 	bool send_tomtou = false, send_writers = false;
89 
90 	if (mode & FMODE_WRITE) {
91 		if (atomic_read(&inode->i_readcount) && IS_IMA(inode)) {
92 			if (!iint)
93 				iint = integrity_iint_find(inode);
94 			/* IMA_MEASURE is set from reader side */
95 			if (iint && (iint->flags & IMA_MEASURE))
96 				send_tomtou = true;
97 		}
98 	} else {
99 		if ((atomic_read(&inode->i_writecount) > 0) && must_measure)
100 			send_writers = true;
101 	}
102 
103 	if (!send_tomtou && !send_writers)
104 		return;
105 
106 	*pathname = ima_d_path(&file->f_path, pathbuf);
107 
108 	if (send_tomtou)
109 		ima_add_violation(file, *pathname, iint,
110 				  "invalid_pcr", "ToMToU");
111 	if (send_writers)
112 		ima_add_violation(file, *pathname, iint,
113 				  "invalid_pcr", "open_writers");
114 }
115 
116 static void ima_check_last_writer(struct integrity_iint_cache *iint,
117 				  struct inode *inode, struct file *file)
118 {
119 	fmode_t mode = file->f_mode;
120 
121 	if (!(mode & FMODE_WRITE))
122 		return;
123 
124 	mutex_lock(&inode->i_mutex);
125 	if (atomic_read(&inode->i_writecount) == 1) {
126 		if ((iint->version != inode->i_version) ||
127 		    (iint->flags & IMA_NEW_FILE)) {
128 			iint->flags &= ~(IMA_DONE_MASK | IMA_NEW_FILE);
129 			if (iint->flags & IMA_APPRAISE)
130 				ima_update_xattr(iint, file);
131 		}
132 	}
133 	mutex_unlock(&inode->i_mutex);
134 }
135 
136 /**
137  * ima_file_free - called on __fput()
138  * @file: pointer to file structure being freed
139  *
140  * Flag files that changed, based on i_version
141  */
142 void ima_file_free(struct file *file)
143 {
144 	struct inode *inode = file_inode(file);
145 	struct integrity_iint_cache *iint;
146 
147 	if (!ima_policy_flag || !S_ISREG(inode->i_mode))
148 		return;
149 
150 	iint = integrity_iint_find(inode);
151 	if (!iint)
152 		return;
153 
154 	ima_check_last_writer(iint, inode, file);
155 }
156 
157 static int process_measurement(struct file *file, int mask, int function,
158 			       int opened)
159 {
160 	struct inode *inode = file_inode(file);
161 	struct integrity_iint_cache *iint = NULL;
162 	struct ima_template_desc *template_desc;
163 	char *pathbuf = NULL;
164 	const char *pathname = NULL;
165 	int rc = -ENOMEM, action, must_appraise;
166 	struct evm_ima_xattr_data *xattr_value = NULL, **xattr_ptr = NULL;
167 	int xattr_len = 0;
168 	bool violation_check;
169 
170 	if (!ima_policy_flag || !S_ISREG(inode->i_mode))
171 		return 0;
172 
173 	/* Return an IMA_MEASURE, IMA_APPRAISE, IMA_AUDIT action
174 	 * bitmask based on the appraise/audit/measurement policy.
175 	 * Included is the appraise submask.
176 	 */
177 	action = ima_get_action(inode, mask, function);
178 	violation_check = ((function == FILE_CHECK || function == MMAP_CHECK) &&
179 			   (ima_policy_flag & IMA_MEASURE));
180 	if (!action && !violation_check)
181 		return 0;
182 
183 	must_appraise = action & IMA_APPRAISE;
184 
185 	/*  Is the appraise rule hook specific?  */
186 	if (action & IMA_FILE_APPRAISE)
187 		function = FILE_CHECK;
188 
189 	mutex_lock(&inode->i_mutex);
190 
191 	if (action) {
192 		iint = integrity_inode_get(inode);
193 		if (!iint)
194 			goto out;
195 	}
196 
197 	if (violation_check) {
198 		ima_rdwr_violation_check(file, iint, action & IMA_MEASURE,
199 					 &pathbuf, &pathname);
200 		if (!action) {
201 			rc = 0;
202 			goto out_free;
203 		}
204 	}
205 
206 	/* Determine if already appraised/measured based on bitmask
207 	 * (IMA_MEASURE, IMA_MEASURED, IMA_XXXX_APPRAISE, IMA_XXXX_APPRAISED,
208 	 *  IMA_AUDIT, IMA_AUDITED)
209 	 */
210 	iint->flags |= action;
211 	action &= IMA_DO_MASK;
212 	action &= ~((iint->flags & IMA_DONE_MASK) >> 1);
213 
214 	/* Nothing to do, just return existing appraised status */
215 	if (!action) {
216 		if (must_appraise)
217 			rc = ima_get_cache_status(iint, function);
218 		goto out_digsig;
219 	}
220 
221 	template_desc = ima_template_desc_current();
222 	if ((action & IMA_APPRAISE_SUBMASK) ||
223 		    strcmp(template_desc->name, IMA_TEMPLATE_IMA_NAME) != 0)
224 		xattr_ptr = &xattr_value;
225 
226 	rc = ima_collect_measurement(iint, file, xattr_ptr, &xattr_len);
227 	if (rc != 0) {
228 		if (file->f_flags & O_DIRECT)
229 			rc = (iint->flags & IMA_PERMIT_DIRECTIO) ? 0 : -EACCES;
230 		goto out_digsig;
231 	}
232 
233 	if (!pathname)	/* ima_rdwr_violation possibly pre-fetched */
234 		pathname = ima_d_path(&file->f_path, &pathbuf);
235 
236 	if (action & IMA_MEASURE)
237 		ima_store_measurement(iint, file, pathname,
238 				      xattr_value, xattr_len);
239 	if (action & IMA_APPRAISE_SUBMASK)
240 		rc = ima_appraise_measurement(function, iint, file, pathname,
241 					      xattr_value, xattr_len, opened);
242 	if (action & IMA_AUDIT)
243 		ima_audit_measurement(iint, pathname);
244 
245 out_digsig:
246 	if ((mask & MAY_WRITE) && (iint->flags & IMA_DIGSIG))
247 		rc = -EACCES;
248 	kfree(xattr_value);
249 out_free:
250 	if (pathbuf)
251 		__putname(pathbuf);
252 out:
253 	mutex_unlock(&inode->i_mutex);
254 	if ((rc && must_appraise) && (ima_appraise & IMA_APPRAISE_ENFORCE))
255 		return -EACCES;
256 	return 0;
257 }
258 
259 /**
260  * ima_file_mmap - based on policy, collect/store measurement.
261  * @file: pointer to the file to be measured (May be NULL)
262  * @prot: contains the protection that will be applied by the kernel.
263  *
264  * Measure files being mmapped executable based on the ima_must_measure()
265  * policy decision.
266  *
267  * On success return 0.  On integrity appraisal error, assuming the file
268  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
269  */
270 int ima_file_mmap(struct file *file, unsigned long prot)
271 {
272 	if (file && (prot & PROT_EXEC))
273 		return process_measurement(file, MAY_EXEC, MMAP_CHECK, 0);
274 	return 0;
275 }
276 
277 /**
278  * ima_bprm_check - based on policy, collect/store measurement.
279  * @bprm: contains the linux_binprm structure
280  *
281  * The OS protects against an executable file, already open for write,
282  * from being executed in deny_write_access() and an executable file,
283  * already open for execute, from being modified in get_write_access().
284  * So we can be certain that what we verify and measure here is actually
285  * what is being executed.
286  *
287  * On success return 0.  On integrity appraisal error, assuming the file
288  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
289  */
290 int ima_bprm_check(struct linux_binprm *bprm)
291 {
292 	return process_measurement(bprm->file, MAY_EXEC, BPRM_CHECK, 0);
293 }
294 
295 /**
296  * ima_path_check - based on policy, collect/store measurement.
297  * @file: pointer to the file to be measured
298  * @mask: contains MAY_READ, MAY_WRITE or MAY_EXECUTE
299  *
300  * Measure files based on the ima_must_measure() policy decision.
301  *
302  * On success return 0.  On integrity appraisal error, assuming the file
303  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
304  */
305 int ima_file_check(struct file *file, int mask, int opened)
306 {
307 	return process_measurement(file,
308 				   mask & (MAY_READ | MAY_WRITE | MAY_EXEC),
309 				   FILE_CHECK, opened);
310 }
311 EXPORT_SYMBOL_GPL(ima_file_check);
312 
313 /**
314  * ima_module_check - based on policy, collect/store/appraise measurement.
315  * @file: pointer to the file to be measured/appraised
316  *
317  * Measure/appraise kernel modules based on policy.
318  *
319  * On success return 0.  On integrity appraisal error, assuming the file
320  * is in policy and IMA-appraisal is in enforcing mode, return -EACCES.
321  */
322 int ima_module_check(struct file *file)
323 {
324 	if (!file) {
325 #ifndef CONFIG_MODULE_SIG_FORCE
326 		if ((ima_appraise & IMA_APPRAISE_MODULES) &&
327 		    (ima_appraise & IMA_APPRAISE_ENFORCE))
328 			return -EACCES;	/* INTEGRITY_UNKNOWN */
329 #endif
330 		return 0;	/* We rely on module signature checking */
331 	}
332 	return process_measurement(file, MAY_EXEC, MODULE_CHECK, 0);
333 }
334 
335 int ima_fw_from_file(struct file *file, char *buf, size_t size)
336 {
337 	if (!file) {
338 		if ((ima_appraise & IMA_APPRAISE_FIRMWARE) &&
339 		    (ima_appraise & IMA_APPRAISE_ENFORCE))
340 			return -EACCES;	/* INTEGRITY_UNKNOWN */
341 		return 0;
342 	}
343 	return process_measurement(file, MAY_EXEC, FIRMWARE_CHECK, 0);
344 }
345 
346 static int __init init_ima(void)
347 {
348 	int error;
349 
350 	hash_setup(CONFIG_IMA_DEFAULT_HASH);
351 	error = ima_init();
352 	if (!error) {
353 		ima_initialized = 1;
354 		ima_update_policy_flag();
355 	}
356 	return error;
357 }
358 
359 late_initcall(init_ima);	/* Start IMA after the TPM is available */
360 
361 MODULE_DESCRIPTION("Integrity Measurement Architecture");
362 MODULE_LICENSE("GPL");
363