evm: permit mode bits to be updated
[linux-2.6.git] / security / integrity / evm / evm_main.c
1 /*
2  * Copyright (C) 2005-2010 IBM Corporation
3  *
4  * Author:
5  * Mimi Zohar <zohar@us.ibm.com>
6  * Kylene Hall <kjhall@us.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, version 2 of the License.
11  *
12  * File: evm_main.c
13  *      implements evm_inode_setxattr, evm_inode_post_setxattr,
14  *      evm_inode_removexattr, and evm_verifyxattr
15  */
16
17 #include <linux/module.h>
18 #include <linux/crypto.h>
19 #include <linux/xattr.h>
20 #include <linux/integrity.h>
21 #include <linux/evm.h>
22 #include <crypto/hash.h>
23 #include "evm.h"
24
25 int evm_initialized;
26
27 char *evm_hmac = "hmac(sha1)";
28
29 char *evm_config_xattrnames[] = {
30 #ifdef CONFIG_SECURITY_SELINUX
31         XATTR_NAME_SELINUX,
32 #endif
33 #ifdef CONFIG_SECURITY_SMACK
34         XATTR_NAME_SMACK,
35 #endif
36         XATTR_NAME_CAPS,
37         NULL
38 };
39
40 static int evm_fixmode;
41 static int __init evm_set_fixmode(char *str)
42 {
43         if (strncmp(str, "fix", 3) == 0)
44                 evm_fixmode = 1;
45         return 0;
46 }
47 __setup("evm=", evm_set_fixmode);
48
49 /*
50  * evm_verify_hmac - calculate and compare the HMAC with the EVM xattr
51  *
52  * Compute the HMAC on the dentry's protected set of extended attributes
53  * and compare it against the stored security.evm xattr.
54  *
55  * For performance:
56  * - use the previoulsy retrieved xattr value and length to calculate the
57  *   HMAC.)
58  * - cache the verification result in the iint, when available.
59  *
60  * Returns integrity status
61  */
62 static enum integrity_status evm_verify_hmac(struct dentry *dentry,
63                                              const char *xattr_name,
64                                              char *xattr_value,
65                                              size_t xattr_value_len,
66                                              struct integrity_iint_cache *iint)
67 {
68         struct evm_ima_xattr_data xattr_data;
69         enum integrity_status evm_status = INTEGRITY_PASS;
70         int rc;
71
72         if (iint && iint->evm_status == INTEGRITY_PASS)
73                 return iint->evm_status;
74
75         /* if status is not PASS, try to check again - against -ENOMEM */
76
77         rc = evm_calc_hmac(dentry, xattr_name, xattr_value,
78                            xattr_value_len, xattr_data.digest);
79         if (rc < 0) {
80                 evm_status = (rc == -ENODATA)
81                     ? INTEGRITY_NOXATTRS : INTEGRITY_FAIL;
82                 goto out;
83         }
84
85         xattr_data.type = EVM_XATTR_HMAC;
86         rc = vfs_xattr_cmp(dentry, XATTR_NAME_EVM, (u8 *)&xattr_data,
87                            sizeof xattr_data, GFP_NOFS);
88         if (rc < 0)
89                 evm_status = (rc == -ENODATA)
90                     ? INTEGRITY_NOLABEL : INTEGRITY_FAIL;
91 out:
92         if (iint)
93                 iint->evm_status = evm_status;
94         return evm_status;
95 }
96
97 static int evm_protected_xattr(const char *req_xattr_name)
98 {
99         char **xattrname;
100         int namelen;
101         int found = 0;
102
103         namelen = strlen(req_xattr_name);
104         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++) {
105                 if ((strlen(*xattrname) == namelen)
106                     && (strncmp(req_xattr_name, *xattrname, namelen) == 0)) {
107                         found = 1;
108                         break;
109                 }
110                 if (strncmp(req_xattr_name,
111                             *xattrname + XATTR_SECURITY_PREFIX_LEN,
112                             strlen(req_xattr_name)) == 0) {
113                         found = 1;
114                         break;
115                 }
116         }
117         return found;
118 }
119
120 /**
121  * evm_verifyxattr - verify the integrity of the requested xattr
122  * @dentry: object of the verify xattr
123  * @xattr_name: requested xattr
124  * @xattr_value: requested xattr value
125  * @xattr_value_len: requested xattr value length
126  *
127  * Calculate the HMAC for the given dentry and verify it against the stored
128  * security.evm xattr. For performance, use the xattr value and length
129  * previously retrieved to calculate the HMAC.
130  *
131  * Returns the xattr integrity status.
132  *
133  * This function requires the caller to lock the inode's i_mutex before it
134  * is executed.
135  */
136 enum integrity_status evm_verifyxattr(struct dentry *dentry,
137                                       const char *xattr_name,
138                                       void *xattr_value, size_t xattr_value_len,
139                                       struct integrity_iint_cache *iint)
140 {
141         if (!evm_initialized || !evm_protected_xattr(xattr_name))
142                 return INTEGRITY_UNKNOWN;
143
144         if (!iint) {
145                 iint = integrity_iint_find(dentry->d_inode);
146                 if (!iint)
147                         return INTEGRITY_UNKNOWN;
148         }
149         return evm_verify_hmac(dentry, xattr_name, xattr_value,
150                                  xattr_value_len, iint);
151 }
152 EXPORT_SYMBOL_GPL(evm_verifyxattr);
153
154 /*
155  * evm_verify_current_integrity - verify the dentry's metadata integrity
156  * @dentry: pointer to the affected dentry
157  *
158  * Verify and return the dentry's metadata integrity. The exceptions are
159  * before EVM is initialized or in 'fix' mode.
160  */
161 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry)
162 {
163         struct inode *inode = dentry->d_inode;
164
165         if (!evm_initialized || !S_ISREG(inode->i_mode) || evm_fixmode)
166                 return 0;
167         return evm_verify_hmac(dentry, NULL, NULL, 0, NULL);
168 }
169
170 /*
171  * evm_protect_xattr - protect the EVM extended attribute
172  *
173  * Prevent security.evm from being modified or removed without the
174  * necessary permissions or when the existing value is invalid.
175  *
176  * The posix xattr acls are 'system' prefixed, which normally would not
177  * affect security.evm.  An interesting side affect of writing posix xattr
178  * acls is their modifying of the i_mode, which is included in security.evm.
179  * For posix xattr acls only, permit security.evm, even if it currently
180  * doesn't exist, to be updated.
181  */
182 static int evm_protect_xattr(struct dentry *dentry, const char *xattr_name,
183                              const void *xattr_value, size_t xattr_value_len)
184 {
185         enum integrity_status evm_status;
186
187         if (strcmp(xattr_name, XATTR_NAME_EVM) == 0) {
188                 if (!capable(CAP_SYS_ADMIN))
189                         return -EPERM;
190         } else if (!evm_protected_xattr(xattr_name)) {
191                 if (!posix_xattr_acl(xattr_name))
192                         return 0;
193                 evm_status = evm_verify_current_integrity(dentry);
194                 if ((evm_status == INTEGRITY_PASS) ||
195                     (evm_status == INTEGRITY_NOXATTRS))
196                         return 0;
197                 return -EPERM;
198         }
199         evm_status = evm_verify_current_integrity(dentry);
200         return evm_status == INTEGRITY_PASS ? 0 : -EPERM;
201 }
202
203 /**
204  * evm_inode_setxattr - protect the EVM extended attribute
205  * @dentry: pointer to the affected dentry
206  * @xattr_name: pointer to the affected extended attribute name
207  * @xattr_value: pointer to the new extended attribute value
208  * @xattr_value_len: pointer to the new extended attribute value length
209  *
210  * Updating 'security.evm' requires CAP_SYS_ADMIN privileges and that
211  * the current value is valid.
212  */
213 int evm_inode_setxattr(struct dentry *dentry, const char *xattr_name,
214                        const void *xattr_value, size_t xattr_value_len)
215 {
216         return evm_protect_xattr(dentry, xattr_name, xattr_value,
217                                  xattr_value_len);
218 }
219
220 /**
221  * evm_inode_removexattr - protect the EVM extended attribute
222  * @dentry: pointer to the affected dentry
223  * @xattr_name: pointer to the affected extended attribute name
224  *
225  * Removing 'security.evm' requires CAP_SYS_ADMIN privileges and that
226  * the current value is valid.
227  */
228 int evm_inode_removexattr(struct dentry *dentry, const char *xattr_name)
229 {
230         return evm_protect_xattr(dentry, xattr_name, NULL, 0);
231 }
232
233 /**
234  * evm_inode_post_setxattr - update 'security.evm' to reflect the changes
235  * @dentry: pointer to the affected dentry
236  * @xattr_name: pointer to the affected extended attribute name
237  * @xattr_value: pointer to the new extended attribute value
238  * @xattr_value_len: pointer to the new extended attribute value length
239  *
240  * Update the HMAC stored in 'security.evm' to reflect the change.
241  *
242  * No need to take the i_mutex lock here, as this function is called from
243  * __vfs_setxattr_noperm().  The caller of which has taken the inode's
244  * i_mutex lock.
245  */
246 void evm_inode_post_setxattr(struct dentry *dentry, const char *xattr_name,
247                              const void *xattr_value, size_t xattr_value_len)
248 {
249         if (!evm_initialized || (!evm_protected_xattr(xattr_name)
250                                  && !posix_xattr_acl(xattr_name)))
251                 return;
252
253         evm_update_evmxattr(dentry, xattr_name, xattr_value, xattr_value_len);
254         return;
255 }
256
257 /**
258  * evm_inode_post_removexattr - update 'security.evm' after removing the xattr
259  * @dentry: pointer to the affected dentry
260  * @xattr_name: pointer to the affected extended attribute name
261  *
262  * Update the HMAC stored in 'security.evm' to reflect removal of the xattr.
263  */
264 void evm_inode_post_removexattr(struct dentry *dentry, const char *xattr_name)
265 {
266         struct inode *inode = dentry->d_inode;
267
268         if (!evm_initialized || !evm_protected_xattr(xattr_name))
269                 return;
270
271         mutex_lock(&inode->i_mutex);
272         evm_update_evmxattr(dentry, xattr_name, NULL, 0);
273         mutex_unlock(&inode->i_mutex);
274         return;
275 }
276
277 /**
278  * evm_inode_setattr - prevent updating an invalid EVM extended attribute
279  * @dentry: pointer to the affected dentry
280  */
281 int evm_inode_setattr(struct dentry *dentry, struct iattr *attr)
282 {
283         unsigned int ia_valid = attr->ia_valid;
284         enum integrity_status evm_status;
285
286         if (!(ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)))
287                 return 0;
288         evm_status = evm_verify_current_integrity(dentry);
289         if ((evm_status == INTEGRITY_PASS) ||
290             (evm_status == INTEGRITY_NOXATTRS))
291                 return 0;
292         return -EPERM;
293 }
294
295 /**
296  * evm_inode_post_setattr - update 'security.evm' after modifying metadata
297  * @dentry: pointer to the affected dentry
298  * @ia_valid: for the UID and GID status
299  *
300  * For now, update the HMAC stored in 'security.evm' to reflect UID/GID
301  * changes.
302  *
303  * This function is called from notify_change(), which expects the caller
304  * to lock the inode's i_mutex.
305  */
306 void evm_inode_post_setattr(struct dentry *dentry, int ia_valid)
307 {
308         if (!evm_initialized)
309                 return;
310
311         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
312                 evm_update_evmxattr(dentry, NULL, NULL, 0);
313         return;
314 }
315
316 /*
317  * evm_inode_init_security - initializes security.evm
318  */
319 int evm_inode_init_security(struct inode *inode,
320                                  const struct xattr *lsm_xattr,
321                                  struct xattr *evm_xattr)
322 {
323         struct evm_ima_xattr_data *xattr_data;
324         int rc;
325
326         if (!evm_initialized || !evm_protected_xattr(lsm_xattr->name))
327                 return 0;
328
329         xattr_data = kzalloc(sizeof(*xattr_data), GFP_NOFS);
330         if (!xattr_data)
331                 return -ENOMEM;
332
333         xattr_data->type = EVM_XATTR_HMAC;
334         rc = evm_init_hmac(inode, lsm_xattr, xattr_data->digest);
335         if (rc < 0)
336                 goto out;
337
338         evm_xattr->value = xattr_data;
339         evm_xattr->value_len = sizeof(*xattr_data);
340         evm_xattr->name = kstrdup(XATTR_EVM_SUFFIX, GFP_NOFS);
341         return 0;
342 out:
343         kfree(xattr_data);
344         return rc;
345 }
346 EXPORT_SYMBOL_GPL(evm_inode_init_security);
347
348 static int __init init_evm(void)
349 {
350         int error;
351
352         error = evm_init_secfs();
353         if (error < 0) {
354                 printk(KERN_INFO "EVM: Error registering secfs\n");
355                 goto err;
356         }
357 err:
358         return error;
359 }
360
361 static void __exit cleanup_evm(void)
362 {
363         evm_cleanup_secfs();
364         if (hmac_tfm)
365                 crypto_free_shash(hmac_tfm);
366 }
367
368 /*
369  * evm_display_config - list the EVM protected security extended attributes
370  */
371 static int __init evm_display_config(void)
372 {
373         char **xattrname;
374
375         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++)
376                 printk(KERN_INFO "EVM: %s\n", *xattrname);
377         return 0;
378 }
379
380 pure_initcall(evm_display_config);
381 late_initcall(init_evm);
382
383 MODULE_DESCRIPTION("Extended Verification Module");
384 MODULE_LICENSE("GPL");