Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /* Updated: Karl MacMillan <kmacmillan@tresys.com>
3 : : *
4 : : * Added conditional policy language extensions
5 : : *
6 : : * Updated: Hewlett-Packard <paul@paul-moore.com>
7 : : *
8 : : * Added support for the policy capability bitmap
9 : : *
10 : : * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
11 : : * Copyright (C) 2003 - 2004 Tresys Technology, LLC
12 : : * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
13 : : */
14 : :
15 : : #include <linux/kernel.h>
16 : : #include <linux/pagemap.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/vmalloc.h>
19 : : #include <linux/fs.h>
20 : : #include <linux/fs_context.h>
21 : : #include <linux/mount.h>
22 : : #include <linux/mutex.h>
23 : : #include <linux/init.h>
24 : : #include <linux/string.h>
25 : : #include <linux/security.h>
26 : : #include <linux/major.h>
27 : : #include <linux/seq_file.h>
28 : : #include <linux/percpu.h>
29 : : #include <linux/audit.h>
30 : : #include <linux/uaccess.h>
31 : : #include <linux/kobject.h>
32 : : #include <linux/ctype.h>
33 : :
34 : : /* selinuxfs pseudo filesystem for exporting the security policy API.
35 : : Based on the proc code and the fs/nfsd/nfsctl.c code. */
36 : :
37 : : #include "flask.h"
38 : : #include "avc.h"
39 : : #include "avc_ss.h"
40 : : #include "security.h"
41 : : #include "objsec.h"
42 : : #include "conditional.h"
43 : :
44 : : enum sel_inos {
45 : : SEL_ROOT_INO = 2,
46 : : SEL_LOAD, /* load policy */
47 : : SEL_ENFORCE, /* get or set enforcing status */
48 : : SEL_CONTEXT, /* validate context */
49 : : SEL_ACCESS, /* compute access decision */
50 : : SEL_CREATE, /* compute create labeling decision */
51 : : SEL_RELABEL, /* compute relabeling decision */
52 : : SEL_USER, /* compute reachable user contexts */
53 : : SEL_POLICYVERS, /* return policy version for this kernel */
54 : : SEL_COMMIT_BOOLS, /* commit new boolean values */
55 : : SEL_MLS, /* return if MLS policy is enabled */
56 : : SEL_DISABLE, /* disable SELinux until next reboot */
57 : : SEL_MEMBER, /* compute polyinstantiation membership decision */
58 : : SEL_CHECKREQPROT, /* check requested protection, not kernel-applied one */
59 : : SEL_COMPAT_NET, /* whether to use old compat network packet controls */
60 : : SEL_REJECT_UNKNOWN, /* export unknown reject handling to userspace */
61 : : SEL_DENY_UNKNOWN, /* export unknown deny handling to userspace */
62 : : SEL_STATUS, /* export current status using mmap() */
63 : : SEL_POLICY, /* allow userspace to read the in kernel policy */
64 : : SEL_VALIDATE_TRANS, /* compute validatetrans decision */
65 : : SEL_INO_NEXT, /* The next inode number to use */
66 : : };
67 : :
68 : : struct selinux_fs_info {
69 : : struct dentry *bool_dir;
70 : : unsigned int bool_num;
71 : : char **bool_pending_names;
72 : : unsigned int *bool_pending_values;
73 : : struct dentry *class_dir;
74 : : unsigned long last_class_ino;
75 : : bool policy_opened;
76 : : struct dentry *policycap_dir;
77 : : struct mutex mutex;
78 : : unsigned long last_ino;
79 : : struct selinux_state *state;
80 : : struct super_block *sb;
81 : : };
82 : :
83 : 30 : static int selinux_fs_info_create(struct super_block *sb)
84 : : {
85 : 30 : struct selinux_fs_info *fsi;
86 : :
87 : 30 : fsi = kzalloc(sizeof(*fsi), GFP_KERNEL);
88 [ + - ]: 30 : if (!fsi)
89 : : return -ENOMEM;
90 : :
91 : 30 : mutex_init(&fsi->mutex);
92 : 30 : fsi->last_ino = SEL_INO_NEXT - 1;
93 : 30 : fsi->state = &selinux_state;
94 : 30 : fsi->sb = sb;
95 : 30 : sb->s_fs_info = fsi;
96 : 30 : return 0;
97 : : }
98 : :
99 : : static void selinux_fs_info_free(struct super_block *sb)
100 : : {
101 : : struct selinux_fs_info *fsi = sb->s_fs_info;
102 : : int i;
103 : :
104 : : if (fsi) {
105 : : for (i = 0; i < fsi->bool_num; i++)
106 : : kfree(fsi->bool_pending_names[i]);
107 : : kfree(fsi->bool_pending_names);
108 : : kfree(fsi->bool_pending_values);
109 : : }
110 : : kfree(sb->s_fs_info);
111 : : sb->s_fs_info = NULL;
112 : : }
113 : :
114 : : #define SEL_INITCON_INO_OFFSET 0x01000000
115 : : #define SEL_BOOL_INO_OFFSET 0x02000000
116 : : #define SEL_CLASS_INO_OFFSET 0x04000000
117 : : #define SEL_POLICYCAP_INO_OFFSET 0x08000000
118 : : #define SEL_INO_MASK 0x00ffffff
119 : :
120 : : #define TMPBUFLEN 12
121 : 30 : static ssize_t sel_read_enforce(struct file *filp, char __user *buf,
122 : : size_t count, loff_t *ppos)
123 : : {
124 : 30 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
125 : 30 : char tmpbuf[TMPBUFLEN];
126 : 30 : ssize_t length;
127 : :
128 : 30 : length = scnprintf(tmpbuf, TMPBUFLEN, "%d",
129 : 30 : enforcing_enabled(fsi->state));
130 : 30 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
131 : : }
132 : :
133 : : #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
134 : 0 : static ssize_t sel_write_enforce(struct file *file, const char __user *buf,
135 : : size_t count, loff_t *ppos)
136 : :
137 : : {
138 [ # # ]: 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
139 : 0 : struct selinux_state *state = fsi->state;
140 : 0 : char *page = NULL;
141 : 0 : ssize_t length;
142 : 0 : int old_value, new_value;
143 : :
144 [ # # ]: 0 : if (count >= PAGE_SIZE)
145 : : return -ENOMEM;
146 : :
147 : : /* No partial writes. */
148 [ # # ]: 0 : if (*ppos != 0)
149 : : return -EINVAL;
150 : :
151 : 0 : page = memdup_user_nul(buf, count);
152 [ # # ]: 0 : if (IS_ERR(page))
153 : 0 : return PTR_ERR(page);
154 : :
155 : 0 : length = -EINVAL;
156 [ # # ]: 0 : if (sscanf(page, "%d", &new_value) != 1)
157 : 0 : goto out;
158 : :
159 : 0 : new_value = !!new_value;
160 : :
161 [ # # ]: 0 : old_value = enforcing_enabled(state);
162 [ # # ]: 0 : if (new_value != old_value) {
163 : 0 : length = avc_has_perm(&selinux_state,
164 : : current_sid(), SECINITSID_SECURITY,
165 : : SECCLASS_SECURITY, SECURITY__SETENFORCE,
166 : : NULL);
167 [ # # ]: 0 : if (length)
168 : 0 : goto out;
169 : 0 : audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS,
170 : : "enforcing=%d old_enforcing=%d auid=%u ses=%u"
171 : : " enabled=1 old-enabled=1 lsm=selinux res=1",
172 : : new_value, old_value,
173 : : from_kuid(&init_user_ns, audit_get_loginuid(current)),
174 : : audit_get_sessionid(current));
175 [ # # ]: 0 : enforcing_set(state, new_value);
176 [ # # ]: 0 : if (new_value)
177 : 0 : avc_ss_reset(state->avc, 0);
178 : 0 : selnl_notify_setenforce(new_value);
179 : 0 : selinux_status_update_setenforce(state, new_value);
180 [ # # ]: 0 : if (!new_value)
181 : 0 : call_blocking_lsm_notifier(LSM_POLICY_CHANGE, NULL);
182 : : }
183 : 0 : length = count;
184 : 0 : out:
185 : 0 : kfree(page);
186 : 0 : return length;
187 : : }
188 : : #else
189 : : #define sel_write_enforce NULL
190 : : #endif
191 : :
192 : : static const struct file_operations sel_enforce_ops = {
193 : : .read = sel_read_enforce,
194 : : .write = sel_write_enforce,
195 : : .llseek = generic_file_llseek,
196 : : };
197 : :
198 : 0 : static ssize_t sel_read_handle_unknown(struct file *filp, char __user *buf,
199 : : size_t count, loff_t *ppos)
200 : : {
201 [ # # ]: 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
202 : 0 : struct selinux_state *state = fsi->state;
203 : 0 : char tmpbuf[TMPBUFLEN];
204 : 0 : ssize_t length;
205 : 0 : ino_t ino = file_inode(filp)->i_ino;
206 : 0 : int handle_unknown = (ino == SEL_REJECT_UNKNOWN) ?
207 [ # # ]: 0 : security_get_reject_unknown(state) :
208 : 0 : !security_get_allow_unknown(state);
209 : :
210 : 0 : length = scnprintf(tmpbuf, TMPBUFLEN, "%d", handle_unknown);
211 : 0 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
212 : : }
213 : :
214 : : static const struct file_operations sel_handle_unknown_ops = {
215 : : .read = sel_read_handle_unknown,
216 : : .llseek = generic_file_llseek,
217 : : };
218 : :
219 : 0 : static int sel_open_handle_status(struct inode *inode, struct file *filp)
220 : : {
221 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
222 : 0 : struct page *status = selinux_kernel_status_page(fsi->state);
223 : :
224 [ # # ]: 0 : if (!status)
225 : : return -ENOMEM;
226 : :
227 : 0 : filp->private_data = status;
228 : :
229 : 0 : return 0;
230 : : }
231 : :
232 : 0 : static ssize_t sel_read_handle_status(struct file *filp, char __user *buf,
233 : : size_t count, loff_t *ppos)
234 : : {
235 : 0 : struct page *status = filp->private_data;
236 : :
237 [ # # ]: 0 : BUG_ON(!status);
238 : :
239 : 0 : return simple_read_from_buffer(buf, count, ppos,
240 : : page_address(status),
241 : : sizeof(struct selinux_kernel_status));
242 : : }
243 : :
244 : 0 : static int sel_mmap_handle_status(struct file *filp,
245 : : struct vm_area_struct *vma)
246 : : {
247 : 0 : struct page *status = filp->private_data;
248 : 0 : unsigned long size = vma->vm_end - vma->vm_start;
249 : :
250 [ # # ]: 0 : BUG_ON(!status);
251 : :
252 : : /* only allows one page from the head */
253 [ # # # # ]: 0 : if (vma->vm_pgoff > 0 || size != PAGE_SIZE)
254 : : return -EIO;
255 : : /* disallow writable mapping */
256 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
257 : : return -EPERM;
258 : : /* disallow mprotect() turns it into writable */
259 : 0 : vma->vm_flags &= ~VM_MAYWRITE;
260 : :
261 : 0 : return remap_pfn_range(vma, vma->vm_start,
262 : 0 : page_to_pfn(status),
263 : : size, vma->vm_page_prot);
264 : : }
265 : :
266 : : static const struct file_operations sel_handle_status_ops = {
267 : : .open = sel_open_handle_status,
268 : : .read = sel_read_handle_status,
269 : : .mmap = sel_mmap_handle_status,
270 : : .llseek = generic_file_llseek,
271 : : };
272 : :
273 : : #ifdef CONFIG_SECURITY_SELINUX_DISABLE
274 : 0 : static ssize_t sel_write_disable(struct file *file, const char __user *buf,
275 : : size_t count, loff_t *ppos)
276 : :
277 : : {
278 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
279 : 0 : char *page;
280 : 0 : ssize_t length;
281 : 0 : int new_value;
282 : 0 : int enforcing;
283 : :
284 : : /* NOTE: we are now officially considering runtime disable as
285 : : * deprecated, and using it will become increasingly painful
286 : : * (e.g. sleeping/blocking) as we progress through future
287 : : * kernel releases until eventually it is removed
288 : : */
289 : 0 : pr_err("SELinux: Runtime disable is deprecated, use selinux=0 on the kernel cmdline.\n");
290 : :
291 [ # # ]: 0 : if (count >= PAGE_SIZE)
292 : : return -ENOMEM;
293 : :
294 : : /* No partial writes. */
295 [ # # ]: 0 : if (*ppos != 0)
296 : : return -EINVAL;
297 : :
298 : 0 : page = memdup_user_nul(buf, count);
299 [ # # ]: 0 : if (IS_ERR(page))
300 : 0 : return PTR_ERR(page);
301 : :
302 : 0 : length = -EINVAL;
303 [ # # ]: 0 : if (sscanf(page, "%d", &new_value) != 1)
304 : 0 : goto out;
305 : :
306 [ # # ]: 0 : if (new_value) {
307 : 0 : enforcing = enforcing_enabled(fsi->state);
308 : 0 : length = selinux_disable(fsi->state);
309 [ # # ]: 0 : if (length)
310 : 0 : goto out;
311 : 0 : audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS,
312 : : "enforcing=%d old_enforcing=%d auid=%u ses=%u"
313 : : " enabled=0 old-enabled=1 lsm=selinux res=1",
314 : : enforcing, enforcing,
315 : : from_kuid(&init_user_ns, audit_get_loginuid(current)),
316 : : audit_get_sessionid(current));
317 : : }
318 : :
319 : 0 : length = count;
320 : 0 : out:
321 : 0 : kfree(page);
322 : 0 : return length;
323 : : }
324 : : #else
325 : : #define sel_write_disable NULL
326 : : #endif
327 : :
328 : : static const struct file_operations sel_disable_ops = {
329 : : .write = sel_write_disable,
330 : : .llseek = generic_file_llseek,
331 : : };
332 : :
333 : 30 : static ssize_t sel_read_policyvers(struct file *filp, char __user *buf,
334 : : size_t count, loff_t *ppos)
335 : : {
336 : 30 : char tmpbuf[TMPBUFLEN];
337 : 30 : ssize_t length;
338 : :
339 : 30 : length = scnprintf(tmpbuf, TMPBUFLEN, "%u", POLICYDB_VERSION_MAX);
340 : 30 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
341 : : }
342 : :
343 : : static const struct file_operations sel_policyvers_ops = {
344 : : .read = sel_read_policyvers,
345 : : .llseek = generic_file_llseek,
346 : : };
347 : :
348 : : /* declaration for sel_write_load */
349 : : static int sel_make_bools(struct selinux_fs_info *fsi);
350 : : static int sel_make_classes(struct selinux_fs_info *fsi);
351 : : static int sel_make_policycap(struct selinux_fs_info *fsi);
352 : :
353 : : /* declaration for sel_make_class_dirs */
354 : : static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
355 : : unsigned long *ino);
356 : :
357 : 0 : static ssize_t sel_read_mls(struct file *filp, char __user *buf,
358 : : size_t count, loff_t *ppos)
359 : : {
360 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
361 : 0 : char tmpbuf[TMPBUFLEN];
362 : 0 : ssize_t length;
363 : :
364 : 0 : length = scnprintf(tmpbuf, TMPBUFLEN, "%d",
365 : : security_mls_enabled(fsi->state));
366 : 0 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
367 : : }
368 : :
369 : : static const struct file_operations sel_mls_ops = {
370 : : .read = sel_read_mls,
371 : : .llseek = generic_file_llseek,
372 : : };
373 : :
374 : : struct policy_load_memory {
375 : : size_t len;
376 : : void *data;
377 : : };
378 : :
379 : 0 : static int sel_open_policy(struct inode *inode, struct file *filp)
380 : : {
381 : 0 : struct selinux_fs_info *fsi = inode->i_sb->s_fs_info;
382 : 0 : struct selinux_state *state = fsi->state;
383 : 0 : struct policy_load_memory *plm = NULL;
384 : 0 : int rc;
385 : :
386 [ # # ]: 0 : BUG_ON(filp->private_data);
387 : :
388 : 0 : mutex_lock(&fsi->mutex);
389 : :
390 : 0 : rc = avc_has_perm(&selinux_state,
391 : : current_sid(), SECINITSID_SECURITY,
392 : : SECCLASS_SECURITY, SECURITY__READ_POLICY, NULL);
393 [ # # ]: 0 : if (rc)
394 : 0 : goto err;
395 : :
396 : 0 : rc = -EBUSY;
397 [ # # ]: 0 : if (fsi->policy_opened)
398 : 0 : goto err;
399 : :
400 : 0 : rc = -ENOMEM;
401 : 0 : plm = kzalloc(sizeof(*plm), GFP_KERNEL);
402 [ # # ]: 0 : if (!plm)
403 : 0 : goto err;
404 : :
405 [ # # ]: 0 : if (i_size_read(inode) != security_policydb_len(state)) {
406 : 0 : inode_lock(inode);
407 : 0 : i_size_write(inode, security_policydb_len(state));
408 : 0 : inode_unlock(inode);
409 : : }
410 : :
411 : 0 : rc = security_read_policy(state, &plm->data, &plm->len);
412 [ # # ]: 0 : if (rc)
413 : 0 : goto err;
414 : :
415 : 0 : fsi->policy_opened = 1;
416 : :
417 : 0 : filp->private_data = plm;
418 : :
419 : 0 : mutex_unlock(&fsi->mutex);
420 : :
421 : 0 : return 0;
422 : 0 : err:
423 : 0 : mutex_unlock(&fsi->mutex);
424 : :
425 [ # # ]: 0 : if (plm)
426 : 0 : vfree(plm->data);
427 : 0 : kfree(plm);
428 : 0 : return rc;
429 : : }
430 : :
431 : 0 : static int sel_release_policy(struct inode *inode, struct file *filp)
432 : : {
433 : 0 : struct selinux_fs_info *fsi = inode->i_sb->s_fs_info;
434 : 0 : struct policy_load_memory *plm = filp->private_data;
435 : :
436 [ # # ]: 0 : BUG_ON(!plm);
437 : :
438 : 0 : fsi->policy_opened = 0;
439 : :
440 : 0 : vfree(plm->data);
441 : 0 : kfree(plm);
442 : :
443 : 0 : return 0;
444 : : }
445 : :
446 : 0 : static ssize_t sel_read_policy(struct file *filp, char __user *buf,
447 : : size_t count, loff_t *ppos)
448 : : {
449 : 0 : struct policy_load_memory *plm = filp->private_data;
450 : 0 : int ret;
451 : :
452 : 0 : ret = avc_has_perm(&selinux_state,
453 : : current_sid(), SECINITSID_SECURITY,
454 : : SECCLASS_SECURITY, SECURITY__READ_POLICY, NULL);
455 [ # # ]: 0 : if (ret)
456 : 0 : return ret;
457 : :
458 : 0 : return simple_read_from_buffer(buf, count, ppos, plm->data, plm->len);
459 : : }
460 : :
461 : 0 : static vm_fault_t sel_mmap_policy_fault(struct vm_fault *vmf)
462 : : {
463 : 0 : struct policy_load_memory *plm = vmf->vma->vm_file->private_data;
464 : 0 : unsigned long offset;
465 : 0 : struct page *page;
466 : :
467 [ # # ]: 0 : if (vmf->flags & (FAULT_FLAG_MKWRITE | FAULT_FLAG_WRITE))
468 : : return VM_FAULT_SIGBUS;
469 : :
470 : 0 : offset = vmf->pgoff << PAGE_SHIFT;
471 [ # # ]: 0 : if (offset >= roundup(plm->len, PAGE_SIZE))
472 : : return VM_FAULT_SIGBUS;
473 : :
474 : 0 : page = vmalloc_to_page(plm->data + offset);
475 [ # # ]: 0 : get_page(page);
476 : :
477 : 0 : vmf->page = page;
478 : :
479 : 0 : return 0;
480 : : }
481 : :
482 : : static const struct vm_operations_struct sel_mmap_policy_ops = {
483 : : .fault = sel_mmap_policy_fault,
484 : : .page_mkwrite = sel_mmap_policy_fault,
485 : : };
486 : :
487 : 0 : static int sel_mmap_policy(struct file *filp, struct vm_area_struct *vma)
488 : : {
489 [ # # ]: 0 : if (vma->vm_flags & VM_SHARED) {
490 : : /* do not allow mprotect to make mapping writable */
491 : 0 : vma->vm_flags &= ~VM_MAYWRITE;
492 : :
493 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
494 : : return -EACCES;
495 : : }
496 : :
497 : 0 : vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
498 : 0 : vma->vm_ops = &sel_mmap_policy_ops;
499 : :
500 : 0 : return 0;
501 : : }
502 : :
503 : : static const struct file_operations sel_policy_ops = {
504 : : .open = sel_open_policy,
505 : : .read = sel_read_policy,
506 : : .mmap = sel_mmap_policy,
507 : : .release = sel_release_policy,
508 : : .llseek = generic_file_llseek,
509 : : };
510 : :
511 : 30 : static int sel_make_policy_nodes(struct selinux_fs_info *fsi)
512 : : {
513 : 30 : int ret;
514 : :
515 : 30 : ret = sel_make_bools(fsi);
516 [ - + ]: 30 : if (ret) {
517 : 0 : pr_err("SELinux: failed to load policy booleans\n");
518 : 0 : return ret;
519 : : }
520 : :
521 : 30 : ret = sel_make_classes(fsi);
522 [ - + ]: 30 : if (ret) {
523 : 0 : pr_err("SELinux: failed to load policy classes\n");
524 : 0 : return ret;
525 : : }
526 : :
527 : 30 : ret = sel_make_policycap(fsi);
528 [ - + ]: 30 : if (ret) {
529 : 0 : pr_err("SELinux: failed to load policy capabilities\n");
530 : 0 : return ret;
531 : : }
532 : :
533 : : return 0;
534 : : }
535 : :
536 : 0 : static ssize_t sel_write_load(struct file *file, const char __user *buf,
537 : : size_t count, loff_t *ppos)
538 : :
539 : : {
540 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
541 : 0 : ssize_t length;
542 : 0 : void *data = NULL;
543 : :
544 : 0 : mutex_lock(&fsi->mutex);
545 : :
546 : 0 : length = avc_has_perm(&selinux_state,
547 : : current_sid(), SECINITSID_SECURITY,
548 : : SECCLASS_SECURITY, SECURITY__LOAD_POLICY, NULL);
549 [ # # ]: 0 : if (length)
550 : 0 : goto out;
551 : :
552 : : /* No partial writes. */
553 : 0 : length = -EINVAL;
554 [ # # ]: 0 : if (*ppos != 0)
555 : 0 : goto out;
556 : :
557 : 0 : length = -ENOMEM;
558 : 0 : data = vmalloc(count);
559 [ # # ]: 0 : if (!data)
560 : 0 : goto out;
561 : :
562 : 0 : length = -EFAULT;
563 [ # # # # ]: 0 : if (copy_from_user(data, buf, count) != 0)
564 : 0 : goto out;
565 : :
566 : 0 : length = security_load_policy(fsi->state, data, count);
567 [ # # ]: 0 : if (length) {
568 [ # # ]: 0 : pr_warn_ratelimited("SELinux: failed to load policy\n");
569 : 0 : goto out;
570 : : }
571 : :
572 : 0 : length = sel_make_policy_nodes(fsi);
573 [ # # ]: 0 : if (length)
574 : 0 : goto out1;
575 : :
576 : 0 : length = count;
577 : :
578 : 0 : out1:
579 : 0 : audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
580 : : "auid=%u ses=%u lsm=selinux res=1",
581 : : from_kuid(&init_user_ns, audit_get_loginuid(current)),
582 : : audit_get_sessionid(current));
583 : 0 : out:
584 : 0 : mutex_unlock(&fsi->mutex);
585 : 0 : vfree(data);
586 : 0 : return length;
587 : : }
588 : :
589 : : static const struct file_operations sel_load_ops = {
590 : : .write = sel_write_load,
591 : : .llseek = generic_file_llseek,
592 : : };
593 : :
594 : 0 : static ssize_t sel_write_context(struct file *file, char *buf, size_t size)
595 : : {
596 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
597 : 0 : struct selinux_state *state = fsi->state;
598 : 0 : char *canon = NULL;
599 : 0 : u32 sid, len;
600 : 0 : ssize_t length;
601 : :
602 : 0 : length = avc_has_perm(&selinux_state,
603 : : current_sid(), SECINITSID_SECURITY,
604 : : SECCLASS_SECURITY, SECURITY__CHECK_CONTEXT, NULL);
605 [ # # ]: 0 : if (length)
606 : 0 : goto out;
607 : :
608 : 0 : length = security_context_to_sid(state, buf, size, &sid, GFP_KERNEL);
609 [ # # ]: 0 : if (length)
610 : 0 : goto out;
611 : :
612 : 0 : length = security_sid_to_context(state, sid, &canon, &len);
613 [ # # ]: 0 : if (length)
614 : 0 : goto out;
615 : :
616 : 0 : length = -ERANGE;
617 [ # # ]: 0 : if (len > SIMPLE_TRANSACTION_LIMIT) {
618 : 0 : pr_err("SELinux: %s: context size (%u) exceeds "
619 : : "payload max\n", __func__, len);
620 : 0 : goto out;
621 : : }
622 : :
623 : 0 : memcpy(buf, canon, len);
624 : 0 : length = len;
625 : 0 : out:
626 : 0 : kfree(canon);
627 : 0 : return length;
628 : : }
629 : :
630 : 0 : static ssize_t sel_read_checkreqprot(struct file *filp, char __user *buf,
631 : : size_t count, loff_t *ppos)
632 : : {
633 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
634 : 0 : char tmpbuf[TMPBUFLEN];
635 : 0 : ssize_t length;
636 : :
637 : 0 : length = scnprintf(tmpbuf, TMPBUFLEN, "%u", fsi->state->checkreqprot);
638 : 0 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
639 : : }
640 : :
641 : 0 : static ssize_t sel_write_checkreqprot(struct file *file, const char __user *buf,
642 : : size_t count, loff_t *ppos)
643 : : {
644 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
645 : 0 : char *page;
646 : 0 : ssize_t length;
647 : 0 : unsigned int new_value;
648 : :
649 : 0 : length = avc_has_perm(&selinux_state,
650 : : current_sid(), SECINITSID_SECURITY,
651 : : SECCLASS_SECURITY, SECURITY__SETCHECKREQPROT,
652 : : NULL);
653 [ # # ]: 0 : if (length)
654 : : return length;
655 : :
656 [ # # ]: 0 : if (count >= PAGE_SIZE)
657 : : return -ENOMEM;
658 : :
659 : : /* No partial writes. */
660 [ # # ]: 0 : if (*ppos != 0)
661 : : return -EINVAL;
662 : :
663 : 0 : page = memdup_user_nul(buf, count);
664 [ # # ]: 0 : if (IS_ERR(page))
665 : 0 : return PTR_ERR(page);
666 : :
667 : 0 : length = -EINVAL;
668 [ # # ]: 0 : if (sscanf(page, "%u", &new_value) != 1)
669 : 0 : goto out;
670 : :
671 : 0 : fsi->state->checkreqprot = new_value ? 1 : 0;
672 : 0 : length = count;
673 : 0 : out:
674 : 0 : kfree(page);
675 : 0 : return length;
676 : : }
677 : : static const struct file_operations sel_checkreqprot_ops = {
678 : : .read = sel_read_checkreqprot,
679 : : .write = sel_write_checkreqprot,
680 : : .llseek = generic_file_llseek,
681 : : };
682 : :
683 : 0 : static ssize_t sel_write_validatetrans(struct file *file,
684 : : const char __user *buf,
685 : : size_t count, loff_t *ppos)
686 : : {
687 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
688 : 0 : struct selinux_state *state = fsi->state;
689 : 0 : char *oldcon = NULL, *newcon = NULL, *taskcon = NULL;
690 : 0 : char *req = NULL;
691 : 0 : u32 osid, nsid, tsid;
692 : 0 : u16 tclass;
693 : 0 : int rc;
694 : :
695 : 0 : rc = avc_has_perm(&selinux_state,
696 : : current_sid(), SECINITSID_SECURITY,
697 : : SECCLASS_SECURITY, SECURITY__VALIDATE_TRANS, NULL);
698 [ # # ]: 0 : if (rc)
699 : 0 : goto out;
700 : :
701 : 0 : rc = -ENOMEM;
702 [ # # ]: 0 : if (count >= PAGE_SIZE)
703 : 0 : goto out;
704 : :
705 : : /* No partial writes. */
706 : 0 : rc = -EINVAL;
707 [ # # ]: 0 : if (*ppos != 0)
708 : 0 : goto out;
709 : :
710 : 0 : req = memdup_user_nul(buf, count);
711 [ # # ]: 0 : if (IS_ERR(req)) {
712 : 0 : rc = PTR_ERR(req);
713 : 0 : req = NULL;
714 : 0 : goto out;
715 : : }
716 : :
717 : 0 : rc = -ENOMEM;
718 : 0 : oldcon = kzalloc(count + 1, GFP_KERNEL);
719 [ # # ]: 0 : if (!oldcon)
720 : 0 : goto out;
721 : :
722 : 0 : newcon = kzalloc(count + 1, GFP_KERNEL);
723 [ # # ]: 0 : if (!newcon)
724 : 0 : goto out;
725 : :
726 : 0 : taskcon = kzalloc(count + 1, GFP_KERNEL);
727 [ # # ]: 0 : if (!taskcon)
728 : 0 : goto out;
729 : :
730 : 0 : rc = -EINVAL;
731 [ # # ]: 0 : if (sscanf(req, "%s %s %hu %s", oldcon, newcon, &tclass, taskcon) != 4)
732 : 0 : goto out;
733 : :
734 : 0 : rc = security_context_str_to_sid(state, oldcon, &osid, GFP_KERNEL);
735 [ # # ]: 0 : if (rc)
736 : 0 : goto out;
737 : :
738 : 0 : rc = security_context_str_to_sid(state, newcon, &nsid, GFP_KERNEL);
739 [ # # ]: 0 : if (rc)
740 : 0 : goto out;
741 : :
742 : 0 : rc = security_context_str_to_sid(state, taskcon, &tsid, GFP_KERNEL);
743 [ # # ]: 0 : if (rc)
744 : 0 : goto out;
745 : :
746 : 0 : rc = security_validate_transition_user(state, osid, nsid, tsid, tclass);
747 [ # # ]: 0 : if (!rc)
748 : 0 : rc = count;
749 : 0 : out:
750 : 0 : kfree(req);
751 : 0 : kfree(oldcon);
752 : 0 : kfree(newcon);
753 : 0 : kfree(taskcon);
754 : 0 : return rc;
755 : : }
756 : :
757 : : static const struct file_operations sel_transition_ops = {
758 : : .write = sel_write_validatetrans,
759 : : .llseek = generic_file_llseek,
760 : : };
761 : :
762 : : /*
763 : : * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
764 : : */
765 : : static ssize_t sel_write_access(struct file *file, char *buf, size_t size);
766 : : static ssize_t sel_write_create(struct file *file, char *buf, size_t size);
767 : : static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size);
768 : : static ssize_t sel_write_user(struct file *file, char *buf, size_t size);
769 : : static ssize_t sel_write_member(struct file *file, char *buf, size_t size);
770 : :
771 : : static ssize_t (*const write_op[])(struct file *, char *, size_t) = {
772 : : [SEL_ACCESS] = sel_write_access,
773 : : [SEL_CREATE] = sel_write_create,
774 : : [SEL_RELABEL] = sel_write_relabel,
775 : : [SEL_USER] = sel_write_user,
776 : : [SEL_MEMBER] = sel_write_member,
777 : : [SEL_CONTEXT] = sel_write_context,
778 : : };
779 : :
780 : 0 : static ssize_t selinux_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
781 : : {
782 [ # # ]: 0 : ino_t ino = file_inode(file)->i_ino;
783 : 0 : char *data;
784 : 0 : ssize_t rv;
785 : :
786 [ # # # # ]: 0 : if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
787 : : return -EINVAL;
788 : :
789 : 0 : data = simple_transaction_get(file, buf, size);
790 [ # # ]: 0 : if (IS_ERR(data))
791 : 0 : return PTR_ERR(data);
792 : :
793 : 0 : rv = write_op[ino](file, data, size);
794 [ # # ]: 0 : if (rv > 0) {
795 : 0 : simple_transaction_set(file, rv);
796 : 0 : rv = size;
797 : : }
798 : : return rv;
799 : : }
800 : :
801 : : static const struct file_operations transaction_ops = {
802 : : .write = selinux_transaction_write,
803 : : .read = simple_transaction_read,
804 : : .release = simple_transaction_release,
805 : : .llseek = generic_file_llseek,
806 : : };
807 : :
808 : : /*
809 : : * payload - write methods
810 : : * If the method has a response, the response should be put in buf,
811 : : * and the length returned. Otherwise return 0 or and -error.
812 : : */
813 : :
814 : 0 : static ssize_t sel_write_access(struct file *file, char *buf, size_t size)
815 : : {
816 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
817 : 0 : struct selinux_state *state = fsi->state;
818 : 0 : char *scon = NULL, *tcon = NULL;
819 : 0 : u32 ssid, tsid;
820 : 0 : u16 tclass;
821 : 0 : struct av_decision avd;
822 : 0 : ssize_t length;
823 : :
824 : 0 : length = avc_has_perm(&selinux_state,
825 : : current_sid(), SECINITSID_SECURITY,
826 : : SECCLASS_SECURITY, SECURITY__COMPUTE_AV, NULL);
827 [ # # ]: 0 : if (length)
828 : 0 : goto out;
829 : :
830 : 0 : length = -ENOMEM;
831 : 0 : scon = kzalloc(size + 1, GFP_KERNEL);
832 [ # # ]: 0 : if (!scon)
833 : 0 : goto out;
834 : :
835 : 0 : length = -ENOMEM;
836 : 0 : tcon = kzalloc(size + 1, GFP_KERNEL);
837 [ # # ]: 0 : if (!tcon)
838 : 0 : goto out;
839 : :
840 : 0 : length = -EINVAL;
841 [ # # ]: 0 : if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
842 : 0 : goto out;
843 : :
844 : 0 : length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
845 [ # # ]: 0 : if (length)
846 : 0 : goto out;
847 : :
848 : 0 : length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
849 [ # # ]: 0 : if (length)
850 : 0 : goto out;
851 : :
852 : 0 : security_compute_av_user(state, ssid, tsid, tclass, &avd);
853 : :
854 : 0 : length = scnprintf(buf, SIMPLE_TRANSACTION_LIMIT,
855 : : "%x %x %x %x %u %x",
856 : : avd.allowed, 0xffffffff,
857 : : avd.auditallow, avd.auditdeny,
858 : : avd.seqno, avd.flags);
859 : 0 : out:
860 : 0 : kfree(tcon);
861 : 0 : kfree(scon);
862 : 0 : return length;
863 : : }
864 : :
865 : 0 : static ssize_t sel_write_create(struct file *file, char *buf, size_t size)
866 : : {
867 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
868 : 0 : struct selinux_state *state = fsi->state;
869 : 0 : char *scon = NULL, *tcon = NULL;
870 : 0 : char *namebuf = NULL, *objname = NULL;
871 : 0 : u32 ssid, tsid, newsid;
872 : 0 : u16 tclass;
873 : 0 : ssize_t length;
874 : 0 : char *newcon = NULL;
875 : 0 : u32 len;
876 : 0 : int nargs;
877 : :
878 : 0 : length = avc_has_perm(&selinux_state,
879 : : current_sid(), SECINITSID_SECURITY,
880 : : SECCLASS_SECURITY, SECURITY__COMPUTE_CREATE,
881 : : NULL);
882 [ # # ]: 0 : if (length)
883 : 0 : goto out;
884 : :
885 : 0 : length = -ENOMEM;
886 : 0 : scon = kzalloc(size + 1, GFP_KERNEL);
887 [ # # ]: 0 : if (!scon)
888 : 0 : goto out;
889 : :
890 : 0 : length = -ENOMEM;
891 : 0 : tcon = kzalloc(size + 1, GFP_KERNEL);
892 [ # # ]: 0 : if (!tcon)
893 : 0 : goto out;
894 : :
895 : 0 : length = -ENOMEM;
896 : 0 : namebuf = kzalloc(size + 1, GFP_KERNEL);
897 [ # # ]: 0 : if (!namebuf)
898 : 0 : goto out;
899 : :
900 : 0 : length = -EINVAL;
901 : 0 : nargs = sscanf(buf, "%s %s %hu %s", scon, tcon, &tclass, namebuf);
902 [ # # ]: 0 : if (nargs < 3 || nargs > 4)
903 : 0 : goto out;
904 [ # # ]: 0 : if (nargs == 4) {
905 : : /*
906 : : * If and when the name of new object to be queried contains
907 : : * either whitespace or multibyte characters, they shall be
908 : : * encoded based on the percentage-encoding rule.
909 : : * If not encoded, the sscanf logic picks up only left-half
910 : : * of the supplied name; splitted by a whitespace unexpectedly.
911 : : */
912 : : char *r, *w;
913 : : int c1, c2;
914 : :
915 : : r = w = namebuf;
916 : 0 : do {
917 : 0 : c1 = *r++;
918 [ # # ]: 0 : if (c1 == '+')
919 : : c1 = ' ';
920 [ # # ]: 0 : else if (c1 == '%') {
921 : 0 : c1 = hex_to_bin(*r++);
922 [ # # ]: 0 : if (c1 < 0)
923 : 0 : goto out;
924 : 0 : c2 = hex_to_bin(*r++);
925 [ # # ]: 0 : if (c2 < 0)
926 : 0 : goto out;
927 : 0 : c1 = (c1 << 4) | c2;
928 : : }
929 : 0 : *w++ = c1;
930 [ # # ]: 0 : } while (c1 != '\0');
931 : :
932 : : objname = namebuf;
933 : : }
934 : :
935 : 0 : length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
936 [ # # ]: 0 : if (length)
937 : 0 : goto out;
938 : :
939 : 0 : length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
940 [ # # ]: 0 : if (length)
941 : 0 : goto out;
942 : :
943 : 0 : length = security_transition_sid_user(state, ssid, tsid, tclass,
944 : : objname, &newsid);
945 [ # # ]: 0 : if (length)
946 : 0 : goto out;
947 : :
948 : 0 : length = security_sid_to_context(state, newsid, &newcon, &len);
949 [ # # ]: 0 : if (length)
950 : 0 : goto out;
951 : :
952 : 0 : length = -ERANGE;
953 [ # # ]: 0 : if (len > SIMPLE_TRANSACTION_LIMIT) {
954 : 0 : pr_err("SELinux: %s: context size (%u) exceeds "
955 : : "payload max\n", __func__, len);
956 : 0 : goto out;
957 : : }
958 : :
959 : 0 : memcpy(buf, newcon, len);
960 : 0 : length = len;
961 : 0 : out:
962 : 0 : kfree(newcon);
963 : 0 : kfree(namebuf);
964 : 0 : kfree(tcon);
965 : 0 : kfree(scon);
966 : 0 : return length;
967 : : }
968 : :
969 : 0 : static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size)
970 : : {
971 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
972 : 0 : struct selinux_state *state = fsi->state;
973 : 0 : char *scon = NULL, *tcon = NULL;
974 : 0 : u32 ssid, tsid, newsid;
975 : 0 : u16 tclass;
976 : 0 : ssize_t length;
977 : 0 : char *newcon = NULL;
978 : 0 : u32 len;
979 : :
980 : 0 : length = avc_has_perm(&selinux_state,
981 : : current_sid(), SECINITSID_SECURITY,
982 : : SECCLASS_SECURITY, SECURITY__COMPUTE_RELABEL,
983 : : NULL);
984 [ # # ]: 0 : if (length)
985 : 0 : goto out;
986 : :
987 : 0 : length = -ENOMEM;
988 : 0 : scon = kzalloc(size + 1, GFP_KERNEL);
989 [ # # ]: 0 : if (!scon)
990 : 0 : goto out;
991 : :
992 : 0 : length = -ENOMEM;
993 : 0 : tcon = kzalloc(size + 1, GFP_KERNEL);
994 [ # # ]: 0 : if (!tcon)
995 : 0 : goto out;
996 : :
997 : 0 : length = -EINVAL;
998 [ # # ]: 0 : if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
999 : 0 : goto out;
1000 : :
1001 : 0 : length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
1002 [ # # ]: 0 : if (length)
1003 : 0 : goto out;
1004 : :
1005 : 0 : length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
1006 [ # # ]: 0 : if (length)
1007 : 0 : goto out;
1008 : :
1009 : 0 : length = security_change_sid(state, ssid, tsid, tclass, &newsid);
1010 [ # # ]: 0 : if (length)
1011 : 0 : goto out;
1012 : :
1013 : 0 : length = security_sid_to_context(state, newsid, &newcon, &len);
1014 [ # # ]: 0 : if (length)
1015 : 0 : goto out;
1016 : :
1017 : 0 : length = -ERANGE;
1018 [ # # ]: 0 : if (len > SIMPLE_TRANSACTION_LIMIT)
1019 : 0 : goto out;
1020 : :
1021 : 0 : memcpy(buf, newcon, len);
1022 : 0 : length = len;
1023 : 0 : out:
1024 : 0 : kfree(newcon);
1025 : 0 : kfree(tcon);
1026 : 0 : kfree(scon);
1027 : 0 : return length;
1028 : : }
1029 : :
1030 : 0 : static ssize_t sel_write_user(struct file *file, char *buf, size_t size)
1031 : : {
1032 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1033 : 0 : struct selinux_state *state = fsi->state;
1034 : 0 : char *con = NULL, *user = NULL, *ptr;
1035 : 0 : u32 sid, *sids = NULL;
1036 : 0 : ssize_t length;
1037 : 0 : char *newcon;
1038 : 0 : int i, rc;
1039 : 0 : u32 len, nsids;
1040 : :
1041 : 0 : length = avc_has_perm(&selinux_state,
1042 : : current_sid(), SECINITSID_SECURITY,
1043 : : SECCLASS_SECURITY, SECURITY__COMPUTE_USER,
1044 : : NULL);
1045 [ # # ]: 0 : if (length)
1046 : 0 : goto out;
1047 : :
1048 : 0 : length = -ENOMEM;
1049 : 0 : con = kzalloc(size + 1, GFP_KERNEL);
1050 [ # # ]: 0 : if (!con)
1051 : 0 : goto out;
1052 : :
1053 : 0 : length = -ENOMEM;
1054 : 0 : user = kzalloc(size + 1, GFP_KERNEL);
1055 [ # # ]: 0 : if (!user)
1056 : 0 : goto out;
1057 : :
1058 : 0 : length = -EINVAL;
1059 [ # # ]: 0 : if (sscanf(buf, "%s %s", con, user) != 2)
1060 : 0 : goto out;
1061 : :
1062 : 0 : length = security_context_str_to_sid(state, con, &sid, GFP_KERNEL);
1063 [ # # ]: 0 : if (length)
1064 : 0 : goto out;
1065 : :
1066 : 0 : length = security_get_user_sids(state, sid, user, &sids, &nsids);
1067 [ # # ]: 0 : if (length)
1068 : 0 : goto out;
1069 : :
1070 : 0 : length = sprintf(buf, "%u", nsids) + 1;
1071 : 0 : ptr = buf + length;
1072 [ # # ]: 0 : for (i = 0; i < nsids; i++) {
1073 : 0 : rc = security_sid_to_context(state, sids[i], &newcon, &len);
1074 [ # # ]: 0 : if (rc) {
1075 : 0 : length = rc;
1076 : 0 : goto out;
1077 : : }
1078 [ # # ]: 0 : if ((length + len) >= SIMPLE_TRANSACTION_LIMIT) {
1079 : 0 : kfree(newcon);
1080 : 0 : length = -ERANGE;
1081 : 0 : goto out;
1082 : : }
1083 : 0 : memcpy(ptr, newcon, len);
1084 : 0 : kfree(newcon);
1085 : 0 : ptr += len;
1086 : 0 : length += len;
1087 : : }
1088 : 0 : out:
1089 : 0 : kfree(sids);
1090 : 0 : kfree(user);
1091 : 0 : kfree(con);
1092 : 0 : return length;
1093 : : }
1094 : :
1095 : 0 : static ssize_t sel_write_member(struct file *file, char *buf, size_t size)
1096 : : {
1097 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1098 : 0 : struct selinux_state *state = fsi->state;
1099 : 0 : char *scon = NULL, *tcon = NULL;
1100 : 0 : u32 ssid, tsid, newsid;
1101 : 0 : u16 tclass;
1102 : 0 : ssize_t length;
1103 : 0 : char *newcon = NULL;
1104 : 0 : u32 len;
1105 : :
1106 : 0 : length = avc_has_perm(&selinux_state,
1107 : : current_sid(), SECINITSID_SECURITY,
1108 : : SECCLASS_SECURITY, SECURITY__COMPUTE_MEMBER,
1109 : : NULL);
1110 [ # # ]: 0 : if (length)
1111 : 0 : goto out;
1112 : :
1113 : 0 : length = -ENOMEM;
1114 : 0 : scon = kzalloc(size + 1, GFP_KERNEL);
1115 [ # # ]: 0 : if (!scon)
1116 : 0 : goto out;
1117 : :
1118 : 0 : length = -ENOMEM;
1119 : 0 : tcon = kzalloc(size + 1, GFP_KERNEL);
1120 [ # # ]: 0 : if (!tcon)
1121 : 0 : goto out;
1122 : :
1123 : 0 : length = -EINVAL;
1124 [ # # ]: 0 : if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
1125 : 0 : goto out;
1126 : :
1127 : 0 : length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
1128 [ # # ]: 0 : if (length)
1129 : 0 : goto out;
1130 : :
1131 : 0 : length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
1132 [ # # ]: 0 : if (length)
1133 : 0 : goto out;
1134 : :
1135 : 0 : length = security_member_sid(state, ssid, tsid, tclass, &newsid);
1136 [ # # ]: 0 : if (length)
1137 : 0 : goto out;
1138 : :
1139 : 0 : length = security_sid_to_context(state, newsid, &newcon, &len);
1140 [ # # ]: 0 : if (length)
1141 : 0 : goto out;
1142 : :
1143 : 0 : length = -ERANGE;
1144 [ # # ]: 0 : if (len > SIMPLE_TRANSACTION_LIMIT) {
1145 : 0 : pr_err("SELinux: %s: context size (%u) exceeds "
1146 : : "payload max\n", __func__, len);
1147 : 0 : goto out;
1148 : : }
1149 : :
1150 : 0 : memcpy(buf, newcon, len);
1151 : 0 : length = len;
1152 : 0 : out:
1153 : 0 : kfree(newcon);
1154 : 0 : kfree(tcon);
1155 : 0 : kfree(scon);
1156 : 0 : return length;
1157 : : }
1158 : :
1159 : 1320 : static struct inode *sel_make_inode(struct super_block *sb, int mode)
1160 : : {
1161 : 1320 : struct inode *ret = new_inode(sb);
1162 : :
1163 [ + - ]: 1320 : if (ret) {
1164 : 1320 : ret->i_mode = mode;
1165 : 1320 : ret->i_atime = ret->i_mtime = ret->i_ctime = current_time(ret);
1166 : : }
1167 : 1320 : return ret;
1168 : : }
1169 : :
1170 : 0 : static ssize_t sel_read_bool(struct file *filep, char __user *buf,
1171 : : size_t count, loff_t *ppos)
1172 : : {
1173 : 0 : struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1174 : 0 : char *page = NULL;
1175 : 0 : ssize_t length;
1176 : 0 : ssize_t ret;
1177 : 0 : int cur_enforcing;
1178 : 0 : unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
1179 : 0 : const char *name = filep->f_path.dentry->d_name.name;
1180 : :
1181 : 0 : mutex_lock(&fsi->mutex);
1182 : :
1183 : 0 : ret = -EINVAL;
1184 [ # # ]: 0 : if (index >= fsi->bool_num || strcmp(name,
1185 [ # # ]: 0 : fsi->bool_pending_names[index]))
1186 : 0 : goto out_unlock;
1187 : :
1188 : 0 : ret = -ENOMEM;
1189 : 0 : page = (char *)get_zeroed_page(GFP_KERNEL);
1190 [ # # ]: 0 : if (!page)
1191 : 0 : goto out_unlock;
1192 : :
1193 : 0 : cur_enforcing = security_get_bool_value(fsi->state, index);
1194 [ # # ]: 0 : if (cur_enforcing < 0) {
1195 : 0 : ret = cur_enforcing;
1196 : 0 : goto out_unlock;
1197 : : }
1198 : 0 : length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
1199 : 0 : fsi->bool_pending_values[index]);
1200 : 0 : mutex_unlock(&fsi->mutex);
1201 : 0 : ret = simple_read_from_buffer(buf, count, ppos, page, length);
1202 : 0 : out_free:
1203 : 0 : free_page((unsigned long)page);
1204 : 0 : return ret;
1205 : :
1206 : 0 : out_unlock:
1207 : 0 : mutex_unlock(&fsi->mutex);
1208 : 0 : goto out_free;
1209 : : }
1210 : :
1211 : 0 : static ssize_t sel_write_bool(struct file *filep, const char __user *buf,
1212 : : size_t count, loff_t *ppos)
1213 : : {
1214 [ # # ]: 0 : struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1215 : 0 : char *page = NULL;
1216 : 0 : ssize_t length;
1217 : 0 : int new_value;
1218 : 0 : unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
1219 : 0 : const char *name = filep->f_path.dentry->d_name.name;
1220 : :
1221 [ # # ]: 0 : if (count >= PAGE_SIZE)
1222 : : return -ENOMEM;
1223 : :
1224 : : /* No partial writes. */
1225 [ # # ]: 0 : if (*ppos != 0)
1226 : : return -EINVAL;
1227 : :
1228 : 0 : page = memdup_user_nul(buf, count);
1229 [ # # ]: 0 : if (IS_ERR(page))
1230 : 0 : return PTR_ERR(page);
1231 : :
1232 : 0 : mutex_lock(&fsi->mutex);
1233 : :
1234 : 0 : length = avc_has_perm(&selinux_state,
1235 : : current_sid(), SECINITSID_SECURITY,
1236 : : SECCLASS_SECURITY, SECURITY__SETBOOL,
1237 : : NULL);
1238 [ # # ]: 0 : if (length)
1239 : 0 : goto out;
1240 : :
1241 : 0 : length = -EINVAL;
1242 [ # # ]: 0 : if (index >= fsi->bool_num || strcmp(name,
1243 [ # # ]: 0 : fsi->bool_pending_names[index]))
1244 : 0 : goto out;
1245 : :
1246 : 0 : length = -EINVAL;
1247 [ # # ]: 0 : if (sscanf(page, "%d", &new_value) != 1)
1248 : 0 : goto out;
1249 : :
1250 [ # # ]: 0 : if (new_value)
1251 : 0 : new_value = 1;
1252 : :
1253 : 0 : fsi->bool_pending_values[index] = new_value;
1254 : 0 : length = count;
1255 : :
1256 : 0 : out:
1257 : 0 : mutex_unlock(&fsi->mutex);
1258 : 0 : kfree(page);
1259 : 0 : return length;
1260 : : }
1261 : :
1262 : : static const struct file_operations sel_bool_ops = {
1263 : : .read = sel_read_bool,
1264 : : .write = sel_write_bool,
1265 : : .llseek = generic_file_llseek,
1266 : : };
1267 : :
1268 : 0 : static ssize_t sel_commit_bools_write(struct file *filep,
1269 : : const char __user *buf,
1270 : : size_t count, loff_t *ppos)
1271 : : {
1272 [ # # ]: 0 : struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1273 : 0 : char *page = NULL;
1274 : 0 : ssize_t length;
1275 : 0 : int new_value;
1276 : :
1277 [ # # ]: 0 : if (count >= PAGE_SIZE)
1278 : : return -ENOMEM;
1279 : :
1280 : : /* No partial writes. */
1281 [ # # ]: 0 : if (*ppos != 0)
1282 : : return -EINVAL;
1283 : :
1284 : 0 : page = memdup_user_nul(buf, count);
1285 [ # # ]: 0 : if (IS_ERR(page))
1286 : 0 : return PTR_ERR(page);
1287 : :
1288 : 0 : mutex_lock(&fsi->mutex);
1289 : :
1290 : 0 : length = avc_has_perm(&selinux_state,
1291 : : current_sid(), SECINITSID_SECURITY,
1292 : : SECCLASS_SECURITY, SECURITY__SETBOOL,
1293 : : NULL);
1294 [ # # ]: 0 : if (length)
1295 : 0 : goto out;
1296 : :
1297 : 0 : length = -EINVAL;
1298 [ # # ]: 0 : if (sscanf(page, "%d", &new_value) != 1)
1299 : 0 : goto out;
1300 : :
1301 : 0 : length = 0;
1302 [ # # # # ]: 0 : if (new_value && fsi->bool_pending_values)
1303 : 0 : length = security_set_bools(fsi->state, fsi->bool_num,
1304 : : fsi->bool_pending_values);
1305 : :
1306 [ # # ]: 0 : if (!length)
1307 : 0 : length = count;
1308 : :
1309 : 0 : out:
1310 : 0 : mutex_unlock(&fsi->mutex);
1311 : 0 : kfree(page);
1312 : 0 : return length;
1313 : : }
1314 : :
1315 : : static const struct file_operations sel_commit_bools_ops = {
1316 : : .write = sel_commit_bools_write,
1317 : : .llseek = generic_file_llseek,
1318 : : };
1319 : :
1320 : 60 : static void sel_remove_entries(struct dentry *de)
1321 : : {
1322 : 60 : d_genocide(de);
1323 : 60 : shrink_dcache_parent(de);
1324 : : }
1325 : :
1326 : : #define BOOL_DIR_NAME "booleans"
1327 : :
1328 : 30 : static int sel_make_bools(struct selinux_fs_info *fsi)
1329 : : {
1330 : 30 : int i, ret;
1331 : 30 : ssize_t len;
1332 : 30 : struct dentry *dentry = NULL;
1333 : 30 : struct dentry *dir = fsi->bool_dir;
1334 : 30 : struct inode *inode = NULL;
1335 : 30 : struct inode_security_struct *isec;
1336 : 30 : char **names = NULL, *page;
1337 : 30 : int num;
1338 : 30 : int *values = NULL;
1339 : 30 : u32 sid;
1340 : :
1341 : : /* remove any existing files */
1342 [ - + ]: 30 : for (i = 0; i < fsi->bool_num; i++)
1343 : 0 : kfree(fsi->bool_pending_names[i]);
1344 : 30 : kfree(fsi->bool_pending_names);
1345 : 30 : kfree(fsi->bool_pending_values);
1346 : 30 : fsi->bool_num = 0;
1347 : 30 : fsi->bool_pending_names = NULL;
1348 : 30 : fsi->bool_pending_values = NULL;
1349 : :
1350 : 30 : sel_remove_entries(dir);
1351 : :
1352 : 30 : ret = -ENOMEM;
1353 : 30 : page = (char *)get_zeroed_page(GFP_KERNEL);
1354 [ - + ]: 30 : if (!page)
1355 : 0 : goto out;
1356 : :
1357 : 30 : ret = security_get_bools(fsi->state, &num, &names, &values);
1358 [ - + ]: 30 : if (ret)
1359 : 0 : goto out;
1360 : :
1361 [ - + ]: 30 : for (i = 0; i < num; i++) {
1362 : 0 : ret = -ENOMEM;
1363 : 0 : dentry = d_alloc_name(dir, names[i]);
1364 [ # # ]: 0 : if (!dentry)
1365 : 0 : goto out;
1366 : :
1367 : 0 : ret = -ENOMEM;
1368 : 0 : inode = sel_make_inode(dir->d_sb, S_IFREG | S_IRUGO | S_IWUSR);
1369 [ # # ]: 0 : if (!inode) {
1370 : 0 : dput(dentry);
1371 : 0 : goto out;
1372 : : }
1373 : :
1374 : 0 : ret = -ENAMETOOLONG;
1375 : 0 : len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
1376 [ # # ]: 0 : if (len >= PAGE_SIZE) {
1377 : 0 : dput(dentry);
1378 : 0 : iput(inode);
1379 : 0 : goto out;
1380 : : }
1381 : :
1382 [ # # ]: 0 : isec = selinux_inode(inode);
1383 : 0 : ret = security_genfs_sid(fsi->state, "selinuxfs", page,
1384 : : SECCLASS_FILE, &sid);
1385 [ # # ]: 0 : if (ret) {
1386 [ # # ]: 0 : pr_warn_ratelimited("SELinux: no sid found, defaulting to security isid for %s\n",
1387 : : page);
1388 : 0 : sid = SECINITSID_SECURITY;
1389 : : }
1390 : :
1391 : 0 : isec->sid = sid;
1392 : 0 : isec->initialized = LABEL_INITIALIZED;
1393 : 0 : inode->i_fop = &sel_bool_ops;
1394 : 0 : inode->i_ino = i|SEL_BOOL_INO_OFFSET;
1395 : 0 : d_add(dentry, inode);
1396 : : }
1397 : 30 : fsi->bool_num = num;
1398 : 30 : fsi->bool_pending_names = names;
1399 : 30 : fsi->bool_pending_values = values;
1400 : :
1401 : 30 : free_page((unsigned long)page);
1402 : 30 : return 0;
1403 : 0 : out:
1404 : 0 : free_page((unsigned long)page);
1405 : :
1406 [ # # ]: 0 : if (names) {
1407 [ # # ]: 0 : for (i = 0; i < num; i++)
1408 : 0 : kfree(names[i]);
1409 : 0 : kfree(names);
1410 : : }
1411 : 0 : kfree(values);
1412 : 0 : sel_remove_entries(dir);
1413 : :
1414 : 0 : return ret;
1415 : : }
1416 : :
1417 : 0 : static ssize_t sel_read_avc_cache_threshold(struct file *filp, char __user *buf,
1418 : : size_t count, loff_t *ppos)
1419 : : {
1420 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1421 : 0 : struct selinux_state *state = fsi->state;
1422 : 0 : char tmpbuf[TMPBUFLEN];
1423 : 0 : ssize_t length;
1424 : :
1425 : 0 : length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1426 : : avc_get_cache_threshold(state->avc));
1427 : 0 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1428 : : }
1429 : :
1430 : 0 : static ssize_t sel_write_avc_cache_threshold(struct file *file,
1431 : : const char __user *buf,
1432 : : size_t count, loff_t *ppos)
1433 : :
1434 : : {
1435 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1436 : 0 : struct selinux_state *state = fsi->state;
1437 : 0 : char *page;
1438 : 0 : ssize_t ret;
1439 : 0 : unsigned int new_value;
1440 : :
1441 : 0 : ret = avc_has_perm(&selinux_state,
1442 : : current_sid(), SECINITSID_SECURITY,
1443 : : SECCLASS_SECURITY, SECURITY__SETSECPARAM,
1444 : : NULL);
1445 [ # # ]: 0 : if (ret)
1446 : : return ret;
1447 : :
1448 [ # # ]: 0 : if (count >= PAGE_SIZE)
1449 : : return -ENOMEM;
1450 : :
1451 : : /* No partial writes. */
1452 [ # # ]: 0 : if (*ppos != 0)
1453 : : return -EINVAL;
1454 : :
1455 : 0 : page = memdup_user_nul(buf, count);
1456 [ # # ]: 0 : if (IS_ERR(page))
1457 : 0 : return PTR_ERR(page);
1458 : :
1459 : 0 : ret = -EINVAL;
1460 [ # # ]: 0 : if (sscanf(page, "%u", &new_value) != 1)
1461 : 0 : goto out;
1462 : :
1463 : 0 : avc_set_cache_threshold(state->avc, new_value);
1464 : :
1465 : 0 : ret = count;
1466 : 0 : out:
1467 : 0 : kfree(page);
1468 : 0 : return ret;
1469 : : }
1470 : :
1471 : 0 : static ssize_t sel_read_avc_hash_stats(struct file *filp, char __user *buf,
1472 : : size_t count, loff_t *ppos)
1473 : : {
1474 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1475 : 0 : struct selinux_state *state = fsi->state;
1476 : 0 : char *page;
1477 : 0 : ssize_t length;
1478 : :
1479 : 0 : page = (char *)__get_free_page(GFP_KERNEL);
1480 [ # # ]: 0 : if (!page)
1481 : : return -ENOMEM;
1482 : :
1483 : 0 : length = avc_get_hash_stats(state->avc, page);
1484 [ # # ]: 0 : if (length >= 0)
1485 : 0 : length = simple_read_from_buffer(buf, count, ppos, page, length);
1486 : 0 : free_page((unsigned long)page);
1487 : :
1488 : 0 : return length;
1489 : : }
1490 : :
1491 : 0 : static ssize_t sel_read_sidtab_hash_stats(struct file *filp, char __user *buf,
1492 : : size_t count, loff_t *ppos)
1493 : : {
1494 : 0 : struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1495 : 0 : struct selinux_state *state = fsi->state;
1496 : 0 : char *page;
1497 : 0 : ssize_t length;
1498 : :
1499 : 0 : page = (char *)__get_free_page(GFP_KERNEL);
1500 [ # # ]: 0 : if (!page)
1501 : : return -ENOMEM;
1502 : :
1503 : 0 : length = security_sidtab_hash_stats(state, page);
1504 [ # # ]: 0 : if (length >= 0)
1505 : 0 : length = simple_read_from_buffer(buf, count, ppos, page,
1506 : : length);
1507 : 0 : free_page((unsigned long)page);
1508 : :
1509 : 0 : return length;
1510 : : }
1511 : :
1512 : : static const struct file_operations sel_sidtab_hash_stats_ops = {
1513 : : .read = sel_read_sidtab_hash_stats,
1514 : : .llseek = generic_file_llseek,
1515 : : };
1516 : :
1517 : : static const struct file_operations sel_avc_cache_threshold_ops = {
1518 : : .read = sel_read_avc_cache_threshold,
1519 : : .write = sel_write_avc_cache_threshold,
1520 : : .llseek = generic_file_llseek,
1521 : : };
1522 : :
1523 : : static const struct file_operations sel_avc_hash_stats_ops = {
1524 : : .read = sel_read_avc_hash_stats,
1525 : : .llseek = generic_file_llseek,
1526 : : };
1527 : :
1528 : : #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1529 : 0 : static struct avc_cache_stats *sel_avc_get_stat_idx(loff_t *idx)
1530 : : {
1531 : 0 : int cpu;
1532 : :
1533 [ # # ]: 0 : for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {
1534 [ # # ]: 0 : if (!cpu_possible(cpu))
1535 : 0 : continue;
1536 : 0 : *idx = cpu + 1;
1537 : 0 : return &per_cpu(avc_cache_stats, cpu);
1538 : : }
1539 : : return NULL;
1540 : : }
1541 : :
1542 : 0 : static void *sel_avc_stats_seq_start(struct seq_file *seq, loff_t *pos)
1543 : : {
1544 : 0 : loff_t n = *pos - 1;
1545 : :
1546 [ # # ]: 0 : if (*pos == 0)
1547 : : return SEQ_START_TOKEN;
1548 : :
1549 : 0 : return sel_avc_get_stat_idx(&n);
1550 : : }
1551 : :
1552 : 0 : static void *sel_avc_stats_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1553 : : {
1554 : 0 : return sel_avc_get_stat_idx(pos);
1555 : : }
1556 : :
1557 : 0 : static int sel_avc_stats_seq_show(struct seq_file *seq, void *v)
1558 : : {
1559 : 0 : struct avc_cache_stats *st = v;
1560 : :
1561 [ # # ]: 0 : if (v == SEQ_START_TOKEN) {
1562 : 0 : seq_puts(seq,
1563 : : "lookups hits misses allocations reclaims frees\n");
1564 : : } else {
1565 : 0 : unsigned int lookups = st->lookups;
1566 : 0 : unsigned int misses = st->misses;
1567 : 0 : unsigned int hits = lookups - misses;
1568 : 0 : seq_printf(seq, "%u %u %u %u %u %u\n", lookups,
1569 : : hits, misses, st->allocations,
1570 : : st->reclaims, st->frees);
1571 : : }
1572 : 0 : return 0;
1573 : : }
1574 : :
1575 : 0 : static void sel_avc_stats_seq_stop(struct seq_file *seq, void *v)
1576 : 0 : { }
1577 : :
1578 : : static const struct seq_operations sel_avc_cache_stats_seq_ops = {
1579 : : .start = sel_avc_stats_seq_start,
1580 : : .next = sel_avc_stats_seq_next,
1581 : : .show = sel_avc_stats_seq_show,
1582 : : .stop = sel_avc_stats_seq_stop,
1583 : : };
1584 : :
1585 : 0 : static int sel_open_avc_cache_stats(struct inode *inode, struct file *file)
1586 : : {
1587 : 0 : return seq_open(file, &sel_avc_cache_stats_seq_ops);
1588 : : }
1589 : :
1590 : : static const struct file_operations sel_avc_cache_stats_ops = {
1591 : : .open = sel_open_avc_cache_stats,
1592 : : .read = seq_read,
1593 : : .llseek = seq_lseek,
1594 : : .release = seq_release,
1595 : : };
1596 : : #endif
1597 : :
1598 : 30 : static int sel_make_avc_files(struct dentry *dir)
1599 : : {
1600 : 30 : struct super_block *sb = dir->d_sb;
1601 : 30 : struct selinux_fs_info *fsi = sb->s_fs_info;
1602 : 30 : int i;
1603 : 30 : static const struct tree_descr files[] = {
1604 : : { "cache_threshold",
1605 : : &sel_avc_cache_threshold_ops, S_IRUGO|S_IWUSR },
1606 : : { "hash_stats", &sel_avc_hash_stats_ops, S_IRUGO },
1607 : : #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1608 : : { "cache_stats", &sel_avc_cache_stats_ops, S_IRUGO },
1609 : : #endif
1610 : : };
1611 : :
1612 [ + + ]: 120 : for (i = 0; i < ARRAY_SIZE(files); i++) {
1613 : 90 : struct inode *inode;
1614 : 90 : struct dentry *dentry;
1615 : :
1616 : 90 : dentry = d_alloc_name(dir, files[i].name);
1617 [ + - ]: 90 : if (!dentry)
1618 : : return -ENOMEM;
1619 : :
1620 : 90 : inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1621 [ - + ]: 90 : if (!inode) {
1622 : 0 : dput(dentry);
1623 : 0 : return -ENOMEM;
1624 : : }
1625 : :
1626 : 90 : inode->i_fop = files[i].ops;
1627 : 90 : inode->i_ino = ++fsi->last_ino;
1628 : 90 : d_add(dentry, inode);
1629 : : }
1630 : :
1631 : : return 0;
1632 : : }
1633 : :
1634 : 30 : static int sel_make_ss_files(struct dentry *dir)
1635 : : {
1636 : 30 : struct super_block *sb = dir->d_sb;
1637 : 30 : struct selinux_fs_info *fsi = sb->s_fs_info;
1638 : 30 : int i;
1639 : 30 : static struct tree_descr files[] = {
1640 : : { "sidtab_hash_stats", &sel_sidtab_hash_stats_ops, S_IRUGO },
1641 : : };
1642 : :
1643 [ + + ]: 60 : for (i = 0; i < ARRAY_SIZE(files); i++) {
1644 : 30 : struct inode *inode;
1645 : 30 : struct dentry *dentry;
1646 : :
1647 : 30 : dentry = d_alloc_name(dir, files[i].name);
1648 [ + - ]: 30 : if (!dentry)
1649 : : return -ENOMEM;
1650 : :
1651 : 30 : inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1652 [ - + ]: 30 : if (!inode) {
1653 : 0 : dput(dentry);
1654 : 0 : return -ENOMEM;
1655 : : }
1656 : :
1657 : 30 : inode->i_fop = files[i].ops;
1658 : 30 : inode->i_ino = ++fsi->last_ino;
1659 : 30 : d_add(dentry, inode);
1660 : : }
1661 : :
1662 : : return 0;
1663 : : }
1664 : :
1665 : 0 : static ssize_t sel_read_initcon(struct file *file, char __user *buf,
1666 : : size_t count, loff_t *ppos)
1667 : : {
1668 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1669 : 0 : char *con;
1670 : 0 : u32 sid, len;
1671 : 0 : ssize_t ret;
1672 : :
1673 : 0 : sid = file_inode(file)->i_ino&SEL_INO_MASK;
1674 : 0 : ret = security_sid_to_context(fsi->state, sid, &con, &len);
1675 [ # # ]: 0 : if (ret)
1676 : : return ret;
1677 : :
1678 : 0 : ret = simple_read_from_buffer(buf, count, ppos, con, len);
1679 : 0 : kfree(con);
1680 : 0 : return ret;
1681 : : }
1682 : :
1683 : : static const struct file_operations sel_initcon_ops = {
1684 : : .read = sel_read_initcon,
1685 : : .llseek = generic_file_llseek,
1686 : : };
1687 : :
1688 : 30 : static int sel_make_initcon_files(struct dentry *dir)
1689 : : {
1690 : 30 : int i;
1691 : :
1692 [ + + ]: 840 : for (i = 1; i <= SECINITSID_NUM; i++) {
1693 : 810 : struct inode *inode;
1694 : 810 : struct dentry *dentry;
1695 : 810 : dentry = d_alloc_name(dir, security_get_initial_sid_context(i));
1696 [ + - ]: 810 : if (!dentry)
1697 : : return -ENOMEM;
1698 : :
1699 : 810 : inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1700 [ - + ]: 810 : if (!inode) {
1701 : 0 : dput(dentry);
1702 : 0 : return -ENOMEM;
1703 : : }
1704 : :
1705 : 810 : inode->i_fop = &sel_initcon_ops;
1706 : 810 : inode->i_ino = i|SEL_INITCON_INO_OFFSET;
1707 : 810 : d_add(dentry, inode);
1708 : : }
1709 : :
1710 : : return 0;
1711 : : }
1712 : :
1713 : 30 : static inline unsigned long sel_class_to_ino(u16 class)
1714 : : {
1715 : 30 : return (class * (SEL_VEC_MAX + 1)) | SEL_CLASS_INO_OFFSET;
1716 : : }
1717 : :
1718 : 0 : static inline u16 sel_ino_to_class(unsigned long ino)
1719 : : {
1720 : 0 : return (ino & SEL_INO_MASK) / (SEL_VEC_MAX + 1);
1721 : : }
1722 : :
1723 : 0 : static inline unsigned long sel_perm_to_ino(u16 class, u32 perm)
1724 : : {
1725 : 0 : return (class * (SEL_VEC_MAX + 1) + perm) | SEL_CLASS_INO_OFFSET;
1726 : : }
1727 : :
1728 : 0 : static inline u32 sel_ino_to_perm(unsigned long ino)
1729 : : {
1730 : 0 : return (ino & SEL_INO_MASK) % (SEL_VEC_MAX + 1);
1731 : : }
1732 : :
1733 : 0 : static ssize_t sel_read_class(struct file *file, char __user *buf,
1734 : : size_t count, loff_t *ppos)
1735 : : {
1736 : 0 : unsigned long ino = file_inode(file)->i_ino;
1737 : 0 : char res[TMPBUFLEN];
1738 : 0 : ssize_t len = scnprintf(res, sizeof(res), "%d", sel_ino_to_class(ino));
1739 : 0 : return simple_read_from_buffer(buf, count, ppos, res, len);
1740 : : }
1741 : :
1742 : : static const struct file_operations sel_class_ops = {
1743 : : .read = sel_read_class,
1744 : : .llseek = generic_file_llseek,
1745 : : };
1746 : :
1747 : 0 : static ssize_t sel_read_perm(struct file *file, char __user *buf,
1748 : : size_t count, loff_t *ppos)
1749 : : {
1750 : 0 : unsigned long ino = file_inode(file)->i_ino;
1751 : 0 : char res[TMPBUFLEN];
1752 : 0 : ssize_t len = scnprintf(res, sizeof(res), "%d", sel_ino_to_perm(ino));
1753 : 0 : return simple_read_from_buffer(buf, count, ppos, res, len);
1754 : : }
1755 : :
1756 : : static const struct file_operations sel_perm_ops = {
1757 : : .read = sel_read_perm,
1758 : : .llseek = generic_file_llseek,
1759 : : };
1760 : :
1761 : 0 : static ssize_t sel_read_policycap(struct file *file, char __user *buf,
1762 : : size_t count, loff_t *ppos)
1763 : : {
1764 : 0 : struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1765 : 0 : int value;
1766 : 0 : char tmpbuf[TMPBUFLEN];
1767 : 0 : ssize_t length;
1768 : 0 : unsigned long i_ino = file_inode(file)->i_ino;
1769 : :
1770 : 0 : value = security_policycap_supported(fsi->state, i_ino & SEL_INO_MASK);
1771 : 0 : length = scnprintf(tmpbuf, TMPBUFLEN, "%d", value);
1772 : :
1773 : 0 : return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1774 : : }
1775 : :
1776 : : static const struct file_operations sel_policycap_ops = {
1777 : : .read = sel_read_policycap,
1778 : : .llseek = generic_file_llseek,
1779 : : };
1780 : :
1781 : 0 : static int sel_make_perm_files(char *objclass, int classvalue,
1782 : : struct dentry *dir)
1783 : : {
1784 : 0 : struct selinux_fs_info *fsi = dir->d_sb->s_fs_info;
1785 : 0 : int i, rc, nperms;
1786 : 0 : char **perms;
1787 : :
1788 : 0 : rc = security_get_permissions(fsi->state, objclass, &perms, &nperms);
1789 [ # # ]: 0 : if (rc)
1790 : : return rc;
1791 : :
1792 [ # # ]: 0 : for (i = 0; i < nperms; i++) {
1793 : 0 : struct inode *inode;
1794 : 0 : struct dentry *dentry;
1795 : :
1796 : 0 : rc = -ENOMEM;
1797 : 0 : dentry = d_alloc_name(dir, perms[i]);
1798 [ # # ]: 0 : if (!dentry)
1799 : 0 : goto out;
1800 : :
1801 : 0 : rc = -ENOMEM;
1802 : 0 : inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1803 [ # # ]: 0 : if (!inode) {
1804 : 0 : dput(dentry);
1805 : 0 : goto out;
1806 : : }
1807 : :
1808 : 0 : inode->i_fop = &sel_perm_ops;
1809 : : /* i+1 since perm values are 1-indexed */
1810 : 0 : inode->i_ino = sel_perm_to_ino(classvalue, i + 1);
1811 : 0 : d_add(dentry, inode);
1812 : : }
1813 : : rc = 0;
1814 : 0 : out:
1815 [ # # ]: 0 : for (i = 0; i < nperms; i++)
1816 : 0 : kfree(perms[i]);
1817 : 0 : kfree(perms);
1818 : 0 : return rc;
1819 : : }
1820 : :
1821 : 0 : static int sel_make_class_dir_entries(char *classname, int index,
1822 : : struct dentry *dir)
1823 : : {
1824 : 0 : struct super_block *sb = dir->d_sb;
1825 : 0 : struct selinux_fs_info *fsi = sb->s_fs_info;
1826 : 0 : struct dentry *dentry = NULL;
1827 : 0 : struct inode *inode = NULL;
1828 : 0 : int rc;
1829 : :
1830 : 0 : dentry = d_alloc_name(dir, "index");
1831 [ # # ]: 0 : if (!dentry)
1832 : : return -ENOMEM;
1833 : :
1834 : 0 : inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1835 [ # # ]: 0 : if (!inode) {
1836 : 0 : dput(dentry);
1837 : 0 : return -ENOMEM;
1838 : : }
1839 : :
1840 : 0 : inode->i_fop = &sel_class_ops;
1841 : 0 : inode->i_ino = sel_class_to_ino(index);
1842 : 0 : d_add(dentry, inode);
1843 : :
1844 : 0 : dentry = sel_make_dir(dir, "perms", &fsi->last_class_ino);
1845 [ # # ]: 0 : if (IS_ERR(dentry))
1846 : 0 : return PTR_ERR(dentry);
1847 : :
1848 : 0 : rc = sel_make_perm_files(classname, index, dentry);
1849 : :
1850 : 0 : return rc;
1851 : : }
1852 : :
1853 : 30 : static int sel_make_classes(struct selinux_fs_info *fsi)
1854 : : {
1855 : :
1856 : 30 : int rc, nclasses, i;
1857 : 30 : char **classes;
1858 : :
1859 : : /* delete any existing entries */
1860 : 30 : sel_remove_entries(fsi->class_dir);
1861 : :
1862 : 30 : rc = security_get_classes(fsi->state, &classes, &nclasses);
1863 [ + - ]: 30 : if (rc)
1864 : : return rc;
1865 : :
1866 : : /* +2 since classes are 1-indexed */
1867 : 30 : fsi->last_class_ino = sel_class_to_ino(nclasses + 2);
1868 : :
1869 [ - + ]: 30 : for (i = 0; i < nclasses; i++) {
1870 : 0 : struct dentry *class_name_dir;
1871 : :
1872 : 0 : class_name_dir = sel_make_dir(fsi->class_dir, classes[i],
1873 : : &fsi->last_class_ino);
1874 [ # # ]: 0 : if (IS_ERR(class_name_dir)) {
1875 : 0 : rc = PTR_ERR(class_name_dir);
1876 : 0 : goto out;
1877 : : }
1878 : :
1879 : : /* i+1 since class values are 1-indexed */
1880 : 0 : rc = sel_make_class_dir_entries(classes[i], i + 1,
1881 : : class_name_dir);
1882 [ # # ]: 0 : if (rc)
1883 : 0 : goto out;
1884 : : }
1885 : : rc = 0;
1886 : 30 : out:
1887 [ - + ]: 30 : for (i = 0; i < nclasses; i++)
1888 : 0 : kfree(classes[i]);
1889 : 30 : kfree(classes);
1890 : 30 : return rc;
1891 : : }
1892 : :
1893 : : static int sel_make_policycap(struct selinux_fs_info *fsi)
1894 : : {
1895 : : unsigned int iter;
1896 : : struct dentry *dentry = NULL;
1897 : : struct inode *inode = NULL;
1898 : :
1899 : : sel_remove_entries(fsi->policycap_dir);
1900 : :
1901 : : for (iter = 0; iter <= POLICYDB_CAPABILITY_MAX; iter++) {
1902 : : if (iter < ARRAY_SIZE(selinux_policycap_names))
1903 : : dentry = d_alloc_name(fsi->policycap_dir,
1904 : : selinux_policycap_names[iter]);
1905 : : else
1906 : : dentry = d_alloc_name(fsi->policycap_dir, "unknown");
1907 : :
1908 : : if (dentry == NULL)
1909 : : return -ENOMEM;
1910 : :
1911 : : inode = sel_make_inode(fsi->sb, S_IFREG | 0444);
1912 : : if (inode == NULL) {
1913 : : dput(dentry);
1914 : : return -ENOMEM;
1915 : : }
1916 : :
1917 : : inode->i_fop = &sel_policycap_ops;
1918 : : inode->i_ino = iter | SEL_POLICYCAP_INO_OFFSET;
1919 : : d_add(dentry, inode);
1920 : : }
1921 : :
1922 : : return 0;
1923 : : }
1924 : :
1925 : 180 : static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
1926 : : unsigned long *ino)
1927 : : {
1928 : 180 : struct dentry *dentry = d_alloc_name(dir, name);
1929 : 180 : struct inode *inode;
1930 : :
1931 [ + - ]: 180 : if (!dentry)
1932 : : return ERR_PTR(-ENOMEM);
1933 : :
1934 : 180 : inode = sel_make_inode(dir->d_sb, S_IFDIR | S_IRUGO | S_IXUGO);
1935 [ - + ]: 180 : if (!inode) {
1936 : 0 : dput(dentry);
1937 : 0 : return ERR_PTR(-ENOMEM);
1938 : : }
1939 : :
1940 : 180 : inode->i_op = &simple_dir_inode_operations;
1941 : 180 : inode->i_fop = &simple_dir_operations;
1942 : 180 : inode->i_ino = ++(*ino);
1943 : : /* directory inodes start off with i_nlink == 2 (for "." entry) */
1944 : 180 : inc_nlink(inode);
1945 : 180 : d_add(dentry, inode);
1946 : : /* bump link count on parent directory, too */
1947 : 180 : inc_nlink(d_inode(dir));
1948 : :
1949 : 180 : return dentry;
1950 : : }
1951 : :
1952 : : #define NULL_FILE_NAME "null"
1953 : :
1954 : 30 : static int sel_fill_super(struct super_block *sb, struct fs_context *fc)
1955 : : {
1956 : 30 : struct selinux_fs_info *fsi;
1957 : 30 : int ret;
1958 : 30 : struct dentry *dentry;
1959 : 30 : struct inode *inode;
1960 : 30 : struct inode_security_struct *isec;
1961 : :
1962 : 30 : static const struct tree_descr selinux_files[] = {
1963 : : [SEL_LOAD] = {"load", &sel_load_ops, S_IRUSR|S_IWUSR},
1964 : : [SEL_ENFORCE] = {"enforce", &sel_enforce_ops, S_IRUGO|S_IWUSR},
1965 : : [SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
1966 : : [SEL_ACCESS] = {"access", &transaction_ops, S_IRUGO|S_IWUGO},
1967 : : [SEL_CREATE] = {"create", &transaction_ops, S_IRUGO|S_IWUGO},
1968 : : [SEL_RELABEL] = {"relabel", &transaction_ops, S_IRUGO|S_IWUGO},
1969 : : [SEL_USER] = {"user", &transaction_ops, S_IRUGO|S_IWUGO},
1970 : : [SEL_POLICYVERS] = {"policyvers", &sel_policyvers_ops, S_IRUGO},
1971 : : [SEL_COMMIT_BOOLS] = {"commit_pending_bools", &sel_commit_bools_ops, S_IWUSR},
1972 : : [SEL_MLS] = {"mls", &sel_mls_ops, S_IRUGO},
1973 : : [SEL_DISABLE] = {"disable", &sel_disable_ops, S_IWUSR},
1974 : : [SEL_MEMBER] = {"member", &transaction_ops, S_IRUGO|S_IWUGO},
1975 : : [SEL_CHECKREQPROT] = {"checkreqprot", &sel_checkreqprot_ops, S_IRUGO|S_IWUSR},
1976 : : [SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
1977 : : [SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
1978 : : [SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
1979 : : [SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUGO},
1980 : : [SEL_VALIDATE_TRANS] = {"validatetrans", &sel_transition_ops,
1981 : : S_IWUGO},
1982 : : /* last one */ {""}
1983 : : };
1984 : :
1985 : 30 : ret = selinux_fs_info_create(sb);
1986 [ - + ]: 30 : if (ret)
1987 : 0 : goto err;
1988 : :
1989 : 30 : ret = simple_fill_super(sb, SELINUX_MAGIC, selinux_files);
1990 [ - + ]: 30 : if (ret)
1991 : 0 : goto err;
1992 : :
1993 : 30 : fsi = sb->s_fs_info;
1994 : 30 : fsi->bool_dir = sel_make_dir(sb->s_root, BOOL_DIR_NAME, &fsi->last_ino);
1995 [ - + ]: 30 : if (IS_ERR(fsi->bool_dir)) {
1996 : 0 : ret = PTR_ERR(fsi->bool_dir);
1997 : 0 : fsi->bool_dir = NULL;
1998 : 0 : goto err;
1999 : : }
2000 : :
2001 : 30 : ret = -ENOMEM;
2002 : 30 : dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
2003 [ - + ]: 30 : if (!dentry)
2004 : 0 : goto err;
2005 : :
2006 : 30 : ret = -ENOMEM;
2007 : 30 : inode = sel_make_inode(sb, S_IFCHR | S_IRUGO | S_IWUGO);
2008 [ - + ]: 30 : if (!inode) {
2009 : 0 : dput(dentry);
2010 : 0 : goto err;
2011 : : }
2012 : :
2013 : 30 : inode->i_ino = ++fsi->last_ino;
2014 [ + - ]: 30 : isec = selinux_inode(inode);
2015 : 30 : isec->sid = SECINITSID_DEVNULL;
2016 : 30 : isec->sclass = SECCLASS_CHR_FILE;
2017 : 30 : isec->initialized = LABEL_INITIALIZED;
2018 : :
2019 : 30 : init_special_inode(inode, S_IFCHR | S_IRUGO | S_IWUGO, MKDEV(MEM_MAJOR, 3));
2020 : 30 : d_add(dentry, inode);
2021 : :
2022 : 30 : dentry = sel_make_dir(sb->s_root, "avc", &fsi->last_ino);
2023 [ - + ]: 30 : if (IS_ERR(dentry)) {
2024 : 0 : ret = PTR_ERR(dentry);
2025 : 0 : goto err;
2026 : : }
2027 : :
2028 : 30 : ret = sel_make_avc_files(dentry);
2029 : :
2030 : 30 : dentry = sel_make_dir(sb->s_root, "ss", &fsi->last_ino);
2031 [ - + ]: 30 : if (IS_ERR(dentry)) {
2032 : 0 : ret = PTR_ERR(dentry);
2033 : 0 : goto err;
2034 : : }
2035 : :
2036 : 30 : ret = sel_make_ss_files(dentry);
2037 [ - + ]: 30 : if (ret)
2038 : 0 : goto err;
2039 : :
2040 : 30 : dentry = sel_make_dir(sb->s_root, "initial_contexts", &fsi->last_ino);
2041 [ - + ]: 30 : if (IS_ERR(dentry)) {
2042 : 0 : ret = PTR_ERR(dentry);
2043 : 0 : goto err;
2044 : : }
2045 : :
2046 : 30 : ret = sel_make_initcon_files(dentry);
2047 [ - + ]: 30 : if (ret)
2048 : 0 : goto err;
2049 : :
2050 : 30 : fsi->class_dir = sel_make_dir(sb->s_root, "class", &fsi->last_ino);
2051 [ - + ]: 30 : if (IS_ERR(fsi->class_dir)) {
2052 : 0 : ret = PTR_ERR(fsi->class_dir);
2053 : 0 : fsi->class_dir = NULL;
2054 : 0 : goto err;
2055 : : }
2056 : :
2057 : 30 : fsi->policycap_dir = sel_make_dir(sb->s_root, "policy_capabilities",
2058 : : &fsi->last_ino);
2059 [ - + ]: 30 : if (IS_ERR(fsi->policycap_dir)) {
2060 : 0 : ret = PTR_ERR(fsi->policycap_dir);
2061 : 0 : fsi->policycap_dir = NULL;
2062 : 0 : goto err;
2063 : : }
2064 : :
2065 : 30 : ret = sel_make_policy_nodes(fsi);
2066 [ - + ]: 30 : if (ret)
2067 : 0 : goto err;
2068 : : return 0;
2069 : 0 : err:
2070 : 0 : pr_err("SELinux: %s: failed while creating inodes\n",
2071 : : __func__);
2072 : :
2073 : 0 : selinux_fs_info_free(sb);
2074 : :
2075 : 0 : return ret;
2076 : : }
2077 : :
2078 : 60 : static int sel_get_tree(struct fs_context *fc)
2079 : : {
2080 : 60 : return get_tree_single(fc, sel_fill_super);
2081 : : }
2082 : :
2083 : : static const struct fs_context_operations sel_context_ops = {
2084 : : .get_tree = sel_get_tree,
2085 : : };
2086 : :
2087 : 60 : static int sel_init_fs_context(struct fs_context *fc)
2088 : : {
2089 : 60 : fc->ops = &sel_context_ops;
2090 : 60 : return 0;
2091 : : }
2092 : :
2093 : 0 : static void sel_kill_sb(struct super_block *sb)
2094 : : {
2095 : 0 : selinux_fs_info_free(sb);
2096 : 0 : kill_litter_super(sb);
2097 : 0 : }
2098 : :
2099 : : static struct file_system_type sel_fs_type = {
2100 : : .name = "selinuxfs",
2101 : : .init_fs_context = sel_init_fs_context,
2102 : : .kill_sb = sel_kill_sb,
2103 : : };
2104 : :
2105 : : struct vfsmount *selinuxfs_mount;
2106 : : struct path selinux_null;
2107 : :
2108 : 30 : static int __init init_sel_fs(void)
2109 : : {
2110 : 30 : struct qstr null_name = QSTR_INIT(NULL_FILE_NAME,
2111 : : sizeof(NULL_FILE_NAME)-1);
2112 : 30 : int err;
2113 : :
2114 [ + - ]: 30 : if (!selinux_enabled_boot)
2115 : : return 0;
2116 : :
2117 : 30 : err = sysfs_create_mount_point(fs_kobj, "selinux");
2118 [ + - ]: 30 : if (err)
2119 : : return err;
2120 : :
2121 : 30 : err = register_filesystem(&sel_fs_type);
2122 [ - + ]: 30 : if (err) {
2123 : 0 : sysfs_remove_mount_point(fs_kobj, "selinux");
2124 : 0 : return err;
2125 : : }
2126 : :
2127 : 30 : selinux_null.mnt = selinuxfs_mount = kern_mount(&sel_fs_type);
2128 [ - + ]: 30 : if (IS_ERR(selinuxfs_mount)) {
2129 : 0 : pr_err("selinuxfs: could not mount!\n");
2130 : 0 : err = PTR_ERR(selinuxfs_mount);
2131 : 0 : selinuxfs_mount = NULL;
2132 : : }
2133 : 30 : selinux_null.dentry = d_hash_and_lookup(selinux_null.mnt->mnt_root,
2134 : : &null_name);
2135 [ - + ]: 30 : if (IS_ERR(selinux_null.dentry)) {
2136 : 0 : pr_err("selinuxfs: could not lookup null!\n");
2137 : 0 : err = PTR_ERR(selinux_null.dentry);
2138 : 0 : selinux_null.dentry = NULL;
2139 : : }
2140 : :
2141 : : return err;
2142 : : }
2143 : :
2144 : : __initcall(init_sel_fs);
2145 : :
2146 : : #ifdef CONFIG_SECURITY_SELINUX_DISABLE
2147 : 0 : void exit_sel_fs(void)
2148 : : {
2149 : 0 : sysfs_remove_mount_point(fs_kobj, "selinux");
2150 : 0 : dput(selinux_null.dentry);
2151 : 0 : kern_unmount(selinuxfs_mount);
2152 : 0 : unregister_filesystem(&sel_fs_type);
2153 : 0 : }
2154 : : #endif
|
