73c008d047c726e53e987db8b2b2b9337b9b5f08
[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;
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                 goto err_out;
81
82         xattr_data.type = EVM_XATTR_HMAC;
83         rc = vfs_xattr_cmp(dentry, XATTR_NAME_EVM, (u8 *)&xattr_data,
84                            sizeof xattr_data, GFP_NOFS);
85         if (rc < 0)
86                 goto err_out;
87         evm_status = INTEGRITY_PASS;
88         goto out;
89
90 err_out:
91         switch (rc) {
92         case -ENODATA:          /* file not labelled */
93                 evm_status = INTEGRITY_NOLABEL;
94                 break;
95         default:
96                 evm_status = INTEGRITY_FAIL;
97         }
98 out:
99         if (iint)
100                 iint->evm_status = evm_status;
101         return evm_status;
102 }
103
104 static int evm_protected_xattr(const char *req_xattr_name)
105 {
106         char **xattrname;
107         int namelen;
108         int found = 0;
109
110         namelen = strlen(req_xattr_name);
111         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++) {
112                 if ((strlen(*xattrname) == namelen)
113                     && (strncmp(req_xattr_name, *xattrname, namelen) == 0)) {
114                         found = 1;
115                         break;
116                 }
117                 if (strncmp(req_xattr_name,
118                             *xattrname + XATTR_SECURITY_PREFIX_LEN,
119                             strlen(req_xattr_name)) == 0) {
120                         found = 1;
121                         break;
122                 }
123         }
124         return found;
125 }
126
127 /**
128  * evm_verifyxattr - verify the integrity of the requested xattr
129  * @dentry: object of the verify xattr
130  * @xattr_name: requested xattr
131  * @xattr_value: requested xattr value
132  * @xattr_value_len: requested xattr value length
133  *
134  * Calculate the HMAC for the given dentry and verify it against the stored
135  * security.evm xattr. For performance, use the xattr value and length
136  * previously retrieved to calculate the HMAC.
137  *
138  * Returns the xattr integrity status.
139  *
140  * This function requires the caller to lock the inode's i_mutex before it
141  * is executed.
142  */
143 enum integrity_status evm_verifyxattr(struct dentry *dentry,
144                                       const char *xattr_name,
145                                       void *xattr_value, size_t xattr_value_len,
146                                       struct integrity_iint_cache *iint)
147 {
148         if (!evm_initialized || !evm_protected_xattr(xattr_name))
149                 return INTEGRITY_UNKNOWN;
150
151         if (!iint) {
152                 iint = integrity_iint_find(dentry->d_inode);
153                 if (!iint)
154                         return INTEGRITY_UNKNOWN;
155         }
156         return evm_verify_hmac(dentry, xattr_name, xattr_value,
157                                  xattr_value_len, iint);
158 }
159 EXPORT_SYMBOL_GPL(evm_verifyxattr);
160
161 /*
162  * evm_verify_current_integrity - verify the dentry's metadata integrity
163  * @dentry: pointer to the affected dentry
164  *
165  * Verify and return the dentry's metadata integrity. The exceptions are
166  * before EVM is initialized or in 'fix' mode.
167  */
168 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry)
169 {
170         struct inode *inode = dentry->d_inode;
171
172         if (!evm_initialized || !S_ISREG(inode->i_mode) || evm_fixmode)
173                 return 0;
174         return evm_verify_hmac(dentry, NULL, NULL, 0, NULL);
175 }
176
177 /*
178  * evm_protect_xattr - protect the EVM extended attribute
179  *
180  * Prevent security.evm from being modified or removed without the
181  * necessary permissions or when the existing value is invalid.
182  *
183  * The posix xattr acls are 'system' prefixed, which normally would not
184  * affect security.evm.  An interesting side affect of writing posix xattr
185  * acls is their modifying of the i_mode, which is included in security.evm.
186  * For posix xattr acls only, permit security.evm, even if it currently
187  * doesn't exist, to be updated.
188  */
189 static int evm_protect_xattr(struct dentry *dentry, const char *xattr_name,
190                              const void *xattr_value, size_t xattr_value_len)
191 {
192         enum integrity_status evm_status;
193
194         if (strcmp(xattr_name, XATTR_NAME_EVM) == 0) {
195                 if (!capable(CAP_SYS_ADMIN))
196                         return -EPERM;
197         } else if (!evm_protected_xattr(xattr_name)) {
198                 if (!posix_xattr_acl(xattr_name))
199                         return 0;
200                 evm_status = evm_verify_current_integrity(dentry);
201                 if ((evm_status == INTEGRITY_PASS) ||
202                         (evm_status == INTEGRITY_NOLABEL))
203                         return 0;
204                 return -EPERM;
205         }
206         evm_status = evm_verify_current_integrity(dentry);
207         return evm_status == INTEGRITY_PASS ? 0 : -EPERM;
208 }
209
210 /**
211  * evm_inode_setxattr - protect the EVM extended attribute
212  * @dentry: pointer to the affected dentry
213  * @xattr_name: pointer to the affected extended attribute name
214  * @xattr_value: pointer to the new extended attribute value
215  * @xattr_value_len: pointer to the new extended attribute value length
216  *
217  * Updating 'security.evm' requires CAP_SYS_ADMIN privileges and that
218  * the current value is valid.
219  */
220 int evm_inode_setxattr(struct dentry *dentry, const char *xattr_name,
221                        const void *xattr_value, size_t xattr_value_len)
222 {
223         return evm_protect_xattr(dentry, xattr_name, xattr_value,
224                                  xattr_value_len);
225 }
226
227 /**
228  * evm_inode_removexattr - protect the EVM extended attribute
229  * @dentry: pointer to the affected dentry
230  * @xattr_name: pointer to the affected extended attribute name
231  *
232  * Removing 'security.evm' requires CAP_SYS_ADMIN privileges and that
233  * the current value is valid.
234  */
235 int evm_inode_removexattr(struct dentry *dentry, const char *xattr_name)
236 {
237         return evm_protect_xattr(dentry, xattr_name, NULL, 0);
238 }
239
240 /**
241  * evm_inode_post_setxattr - update 'security.evm' to reflect the changes
242  * @dentry: pointer to the affected dentry
243  * @xattr_name: pointer to the affected extended attribute name
244  * @xattr_value: pointer to the new extended attribute value
245  * @xattr_value_len: pointer to the new extended attribute value length
246  *
247  * Update the HMAC stored in 'security.evm' to reflect the change.
248  *
249  * No need to take the i_mutex lock here, as this function is called from
250  * __vfs_setxattr_noperm().  The caller of which has taken the inode's
251  * i_mutex lock.
252  */
253 void evm_inode_post_setxattr(struct dentry *dentry, const char *xattr_name,
254                              const void *xattr_value, size_t xattr_value_len)
255 {
256         if (!evm_initialized || (!evm_protected_xattr(xattr_name)
257                                  && !posix_xattr_acl(xattr_name)))
258                 return;
259
260         evm_update_evmxattr(dentry, xattr_name, xattr_value, xattr_value_len);
261         return;
262 }
263
264 /**
265  * evm_inode_post_removexattr - update 'security.evm' after removing the xattr
266  * @dentry: pointer to the affected dentry
267  * @xattr_name: pointer to the affected extended attribute name
268  *
269  * Update the HMAC stored in 'security.evm' to reflect removal of the xattr.
270  */
271 void evm_inode_post_removexattr(struct dentry *dentry, const char *xattr_name)
272 {
273         struct inode *inode = dentry->d_inode;
274
275         if (!evm_initialized || !evm_protected_xattr(xattr_name))
276                 return;
277
278         mutex_lock(&inode->i_mutex);
279         evm_update_evmxattr(dentry, xattr_name, NULL, 0);
280         mutex_unlock(&inode->i_mutex);
281         return;
282 }
283
284 /**
285  * evm_inode_setattr - prevent updating an invalid EVM extended attribute
286  * @dentry: pointer to the affected dentry
287  */
288 int evm_inode_setattr(struct dentry *dentry, struct iattr *attr)
289 {
290         unsigned int ia_valid = attr->ia_valid;
291         enum integrity_status evm_status;
292
293         if (!(ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)))
294                 return 0;
295         evm_status = evm_verify_current_integrity(dentry);
296         return evm_status == INTEGRITY_PASS ? 0 : -EPERM;
297 }
298
299 /**
300  * evm_inode_post_setattr - update 'security.evm' after modifying metadata
301  * @dentry: pointer to the affected dentry
302  * @ia_valid: for the UID and GID status
303  *
304  * For now, update the HMAC stored in 'security.evm' to reflect UID/GID
305  * changes.
306  *
307  * This function is called from notify_change(), which expects the caller
308  * to lock the inode's i_mutex.
309  */
310 void evm_inode_post_setattr(struct dentry *dentry, int ia_valid)
311 {
312         if (!evm_initialized)
313                 return;
314
315         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
316                 evm_update_evmxattr(dentry, NULL, NULL, 0);
317         return;
318 }
319
320 /*
321  * evm_inode_init_security - initializes security.evm
322  */
323 int evm_inode_init_security(struct inode *inode,
324                                  const struct xattr *lsm_xattr,
325                                  struct xattr *evm_xattr)
326 {
327         struct evm_ima_xattr_data *xattr_data;
328         int rc;
329
330         if (!evm_initialized || !evm_protected_xattr(lsm_xattr->name))
331                 return 0;
332
333         xattr_data = kzalloc(sizeof(*xattr_data), GFP_NOFS);
334         if (!xattr_data)
335                 return -ENOMEM;
336
337         xattr_data->type = EVM_XATTR_HMAC;
338         rc = evm_init_hmac(inode, lsm_xattr, xattr_data->digest);
339         if (rc < 0)
340                 goto out;
341
342         evm_xattr->value = xattr_data;
343         evm_xattr->value_len = sizeof(*xattr_data);
344         evm_xattr->name = kstrdup(XATTR_EVM_SUFFIX, GFP_NOFS);
345         return 0;
346 out:
347         kfree(xattr_data);
348         return rc;
349 }
350 EXPORT_SYMBOL_GPL(evm_inode_init_security);
351
352 static int __init init_evm(void)
353 {
354         int error;
355
356         error = evm_init_secfs();
357         if (error < 0) {
358                 printk(KERN_INFO "EVM: Error registering secfs\n");
359                 goto err;
360         }
361 err:
362         return error;
363 }
364
365 static void __exit cleanup_evm(void)
366 {
367         evm_cleanup_secfs();
368         if (hmac_tfm)
369                 crypto_free_shash(hmac_tfm);
370 }
371
372 /*
373  * evm_display_config - list the EVM protected security extended attributes
374  */
375 static int __init evm_display_config(void)
376 {
377         char **xattrname;
378
379         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++)
380                 printk(KERN_INFO "EVM: %s\n", *xattrname);
381         return 0;
382 }
383
384 pure_initcall(evm_display_config);
385 late_initcall(init_evm);
386
387 MODULE_DESCRIPTION("Extended Verification Module");
388 MODULE_LICENSE("GPL");