~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/security/integrity/evm/evm_secfs.c

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp