1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2010 IBM Corporation
4 *
5 * Authors:
6 * Mimi Zohar <zohar@us.ibm.com>
7 *
8 * File: evm_secfs.c
9 * - Used to signal when key is on keyring
10 * - Get the key and enable EVM
11 */
12
13 #include <linux/audit.h>
14 #include <linux/uaccess.h>
15 #include <linux/init.h>
16 #include <linux/mutex.h>
17 #include "evm.h"
18
19 static struct dentry *evm_dir;
20 static struct dentry *evm_init_tpm;
21 static struct dentry *evm_symlink;
22
23 #ifdef CONFIG_EVM_ADD_XATTRS
24 static struct dentry *evm_xattrs;
25 static DEFINE_MUTEX(xattr_list_mutex);
26 static int evm_xattrs_locked;
27 #endif
28
29 /**
30 * evm_read_key - read() for <securityfs>/evm
31 *
32 * @filp: file pointer, not actually used
33 * @buf: where to put the result
34 * @count: maximum to send along
35 * @ppos: where to start
36 *
37 * Returns number of bytes read or error code, as appropriate
38 */
39 static ssize_t evm_read_key(struct file *filp, char __user *buf,
40 size_t count, loff_t *ppos)
41 {
42 char temp[80];
43 ssize_t rc;
44
45 if (*ppos != 0)
46 return 0;
47
48 sprintf(temp, "%d", (evm_initialized & ~EVM_SETUP_COMPLETE));
49 rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
50
51 return rc;
52 }
53
54 /**
55 * evm_write_key - write() for <securityfs>/evm
56 * @file: file pointer, not actually used
57 * @buf: where to get the data from
58 * @count: bytes sent
59 * @ppos: where to start
60 *
61 * Used to signal that key is on the kernel key ring.
62 * - get the integrity hmac key from the kernel key ring
63 * - create list of hmac protected extended attributes
64 * Returns number of bytes written or error code, as appropriate
65 */
66 static ssize_t evm_write_key(struct file *file, const char __user *buf,
67 size_t count, loff_t *ppos)
68 {
69 unsigned int i;
70 int ret;
71
72 if (!capable(CAP_SYS_ADMIN) || (evm_initialized & EVM_SETUP_COMPLETE))
73 return -EPERM;
74
75 ret = kstrtouint_from_user(buf, count, 0, &i);
76
77 if (ret)
78 return ret;
79
80 /* Reject invalid values */
81 if (!i || (i & ~EVM_INIT_MASK) != 0)
82 return -EINVAL;
83
84 /*
85 * Don't allow a request to enable metadata writes if
86 * an HMAC key is loaded.
87 */
88 if ((i & EVM_ALLOW_METADATA_WRITES) &&
89 (evm_initialized & EVM_INIT_HMAC) != 0)
90 return -EPERM;
91
92 if (i & EVM_INIT_HMAC) {
93 ret = evm_init_key();
94 if (ret != 0)
95 return ret;
96 /* Forbid further writes after the symmetric key is loaded */
97 i |= EVM_SETUP_COMPLETE;
98 }
99
100 evm_initialized |= i;
101
102 /* Don't allow protected metadata modification if a symmetric key
103 * is loaded
104 */
105 if (evm_initialized & EVM_INIT_HMAC)
106 evm_initialized &= ~(EVM_ALLOW_METADATA_WRITES);
107
108 return count;
109 }
110
111 static const struct file_operations evm_key_ops = {
112 .read = evm_read_key,
113 .write = evm_write_key,
114 };
115
116 #ifdef CONFIG_EVM_ADD_XATTRS
117 /**
118 * evm_read_xattrs - read() for <securityfs>/evm_xattrs
119 *
120 * @filp: file pointer, not actually used
121 * @buf: where to put the result
122 * @count: maximum to send along
123 * @ppos: where to start
124 *
125 * Returns number of bytes read or error code, as appropriate
126 */
127 static ssize_t evm_read_xattrs(struct file *filp, char __user *buf,
128 size_t count, loff_t *ppos)
129 {
130 char *temp;
131 int offset = 0;
132 ssize_t rc, size = 0;
133 struct xattr_list *xattr;
134
135 if (*ppos != 0)
136 return 0;
137
138 rc = mutex_lock_interruptible(&xattr_list_mutex);
139 if (rc)
140 return -ERESTARTSYS;
141
142 list_for_each_entry(xattr, &evm_config_xattrnames, list) {
143 if (!xattr->enabled)
144 continue;
145
146 size += strlen(xattr->name) + 1;
147 }
148
149 temp = kmalloc(size + 1, GFP_KERNEL);
150 if (!temp) {
151 mutex_unlock(&xattr_list_mutex);
152 return -ENOMEM;
153 }
154
155 list_for_each_entry(xattr, &evm_config_xattrnames, list) {
156 if (!xattr->enabled)
157 continue;
158
159 sprintf(temp + offset, "%s\n", xattr->name);
160 offset += strlen(xattr->name) + 1;
161 }
162
163 mutex_unlock(&xattr_list_mutex);
164 rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
165
166 kfree(temp);
167
168 return rc;
169 }
170
171 /**
172 * evm_write_xattrs - write() for <securityfs>/evm_xattrs
173 * @file: file pointer, not actually used
174 * @buf: where to get the data from
175 * @count: bytes sent
176 * @ppos: where to start
177 *
178 * Returns number of bytes written or error code, as appropriate
179 */
180 static ssize_t evm_write_xattrs(struct file *file, const char __user *buf,
181 size_t count, loff_t *ppos)
182 {
183 int len, err;
184 struct xattr_list *xattr, *tmp;
185 struct audit_buffer *ab;
186 struct iattr newattrs;
187 struct inode *inode;
188
189 if (!capable(CAP_SYS_ADMIN) || evm_xattrs_locked)
190 return -EPERM;
191
192 if (*ppos != 0)
193 return -EINVAL;
194
195 if (count > XATTR_NAME_MAX)
196 return -E2BIG;
197
198 ab = audit_log_start(audit_context(), GFP_KERNEL,
199 AUDIT_INTEGRITY_EVM_XATTR);
200 if (!ab && IS_ENABLED(CONFIG_AUDIT))
201 return -ENOMEM;
202
203 xattr = kmalloc(sizeof(struct xattr_list), GFP_KERNEL);
204 if (!xattr) {
205 err = -ENOMEM;
206 goto out;
207 }
208
209 xattr->enabled = true;
210 xattr->name = memdup_user_nul(buf, count);
211 if (IS_ERR(xattr->name)) {
212 err = PTR_ERR(xattr->name);
213 xattr->name = NULL;
214 goto out;
215 }
216
217 /* Remove any trailing newline */
218 len = strlen(xattr->name);
219 if (len && xattr->name[len-1] == '\n')
220 xattr->name[len-1] = '\0';
221
222 audit_log_format(ab, "xattr=");
223 audit_log_untrustedstring(ab, xattr->name);
224
225 if (strcmp(xattr->name, ".") == 0) {
226 evm_xattrs_locked = 1;
227 newattrs.ia_mode = S_IFREG | 0440;
228 newattrs.ia_valid = ATTR_MODE;
229 inode = evm_xattrs->d_inode;
230 inode_lock(inode);
231 err = simple_setattr(&nop_mnt_idmap, evm_xattrs, &newattrs);
232 inode_unlock(inode);
233 if (!err)
234 err = count;
235 goto out;
236 }
237
238 if (strncmp(xattr->name, XATTR_SECURITY_PREFIX,
239 XATTR_SECURITY_PREFIX_LEN) != 0) {
240 err = -EINVAL;
241 goto out;
242 }
243
244 /*
245 * xattr_list_mutex guards against races in evm_read_xattrs().
246 * Entries are only added to the evm_config_xattrnames list
247 * and never deleted. Therefore, the list is traversed
248 * using list_for_each_entry_lockless() without holding
249 * the mutex in evm_calc_hmac_or_hash(), evm_find_protected_xattrs()
250 * and evm_protected_xattr().
251 */
252 mutex_lock(&xattr_list_mutex);
253 list_for_each_entry(tmp, &evm_config_xattrnames, list) {
254 if (strcmp(xattr->name, tmp->name) == 0) {
255 err = -EEXIST;
256 if (!tmp->enabled) {
257 tmp->enabled = true;
258 err = count;
259 }
260 mutex_unlock(&xattr_list_mutex);
261 goto out;
262 }
263 }
264 list_add_tail_rcu(&xattr->list, &evm_config_xattrnames);
265 mutex_unlock(&xattr_list_mutex);
266
267 audit_log_format(ab, " res=0");
268 audit_log_end(ab);
269 return count;
270 out:
271 audit_log_format(ab, " res=%d", (err < 0) ? err : 0);
272 audit_log_end(ab);
273 if (xattr) {
274 kfree(xattr->name);
275 kfree(xattr);
276 }
277 return err;
278 }
279
280 static const struct file_operations evm_xattr_ops = {
281 .read = evm_read_xattrs,
282 .write = evm_write_xattrs,
283 };
284
285 static int evm_init_xattrs(void)
286 {
287 evm_xattrs = securityfs_create_file("evm_xattrs", 0660, evm_dir, NULL,
288 &evm_xattr_ops);
289 if (!evm_xattrs || IS_ERR(evm_xattrs))
290 return -EFAULT;
291
292 return 0;
293 }
294 #else
295 static int evm_init_xattrs(void)
296 {
297 return 0;
298 }
299 #endif
300
301 int __init evm_init_secfs(void)
302 {
303 int error = 0;
304
305 evm_dir = securityfs_create_dir("evm", integrity_dir);
306 if (!evm_dir || IS_ERR(evm_dir))
307 return -EFAULT;
308
309 evm_init_tpm = securityfs_create_file("evm", 0660,
310 evm_dir, NULL, &evm_key_ops);
311 if (!evm_init_tpm || IS_ERR(evm_init_tpm)) {
312 error = -EFAULT;
313 goto out;
314 }
315
316 evm_symlink = securityfs_create_symlink("evm", NULL,
317 "integrity/evm/evm", NULL);
318 if (!evm_symlink || IS_ERR(evm_symlink)) {
319 error = -EFAULT;
320 goto out;
321 }
322
323 if (evm_init_xattrs() != 0) {
324 error = -EFAULT;
325 goto out;
326 }
327
328 return 0;
329 out:
330 securityfs_remove(evm_symlink);
331 securityfs_remove(evm_init_tpm);
332 securityfs_remove(evm_dir);
333 return error;
334 }
335
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.