1 /*-
2 * Copyright (c) 2008-2011 Robert N. M. Watson
3 * Copyright (c) 2010-2011 Jonathan Anderson
4 * All rights reserved.
5 *
6 * This software was developed at the University of Cambridge Computer
7 * Laboratory with support from a grant from Google, Inc.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 /*
32 * FreeBSD kernel capability facility.
33 *
34 * Two kernel features are implemented here: capability mode, a sandboxed mode
35 * of execution for processes, and capabilities, a refinement on file
36 * descriptors that allows fine-grained control over operations on the file
37 * descriptor. Collectively, these allow processes to run in the style of a
38 * historic "capability system" in which they can use only resources
39 * explicitly delegated to them. This model is enforced by restricting access
40 * to global namespaces in capability mode.
41 *
42 * Capabilities wrap other file descriptor types, binding them to a constant
43 * rights mask set when the capability is created. New capabilities may be
44 * derived from existing capabilities, but only if they have the same or a
45 * strict subset of the rights on the original capability.
46 *
47 * System calls permitted in capability mode are defined in capabilities.conf;
48 * calls must be carefully audited for safety to ensure that they don't allow
49 * escape from a sandbox. Some calls permit only a subset of operations in
50 * capability mode -- for example, shm_open(2) is limited to creating
51 * anonymous, rather than named, POSIX shared memory objects.
52 */
53
54 #include "opt_capsicum.h"
55
56 #include <sys/cdefs.h>
57 __FBSDID("$FreeBSD: releng/9.0/sys/kern/sys_capability.c 225617 2011-09-16 13:58:51Z kmacy $");
58
59 #include <sys/param.h>
60 #include <sys/capability.h>
61 #include <sys/file.h>
62 #include <sys/filedesc.h>
63 #include <sys/kernel.h>
64 #include <sys/lock.h>
65 #include <sys/mutex.h>
66 #include <sys/proc.h>
67 #include <sys/sysproto.h>
68 #include <sys/sysctl.h>
69 #include <sys/systm.h>
70 #include <sys/ucred.h>
71
72 #include <security/audit/audit.h>
73
74 #include <vm/uma.h>
75 #include <vm/vm.h>
76
77 #ifdef CAPABILITY_MODE
78
79 FEATURE(security_capability_mode, "Capsicum Capability Mode");
80
81 /*
82 * System call to enter capability mode for the process.
83 */
84 int
85 sys_cap_enter(struct thread *td, struct cap_enter_args *uap)
86 {
87 struct ucred *newcred, *oldcred;
88 struct proc *p;
89
90 if (IN_CAPABILITY_MODE(td))
91 return (0);
92
93 newcred = crget();
94 p = td->td_proc;
95 PROC_LOCK(p);
96 oldcred = p->p_ucred;
97 crcopy(newcred, oldcred);
98 newcred->cr_flags |= CRED_FLAG_CAPMODE;
99 p->p_ucred = newcred;
100 PROC_UNLOCK(p);
101 crfree(oldcred);
102 return (0);
103 }
104
105 /*
106 * System call to query whether the process is in capability mode.
107 */
108 int
109 sys_cap_getmode(struct thread *td, struct cap_getmode_args *uap)
110 {
111 u_int i;
112
113 i = (IN_CAPABILITY_MODE(td)) ? 1 : 0;
114 return (copyout(&i, uap->modep, sizeof(i)));
115 }
116
117 #else /* !CAPABILITY_MODE */
118
119 int
120 sys_cap_enter(struct thread *td, struct cap_enter_args *uap)
121 {
122
123 return (ENOSYS);
124 }
125
126 int
127 sys_cap_getmode(struct thread *td, struct cap_getmode_args *uap)
128 {
129
130 return (ENOSYS);
131 }
132
133 #endif /* CAPABILITY_MODE */
134
135 #ifdef CAPABILITIES
136
137 FEATURE(security_capabilities, "Capsicum Capabilities");
138
139 /*
140 * struct capability describes a capability, and is hung off of its struct
141 * file f_data field. cap_file and cap_rightss are static once hooked up, as
142 * neither the object it references nor the rights it encapsulates are
143 * permitted to change.
144 */
145 struct capability {
146 struct file *cap_object; /* Underlying object's file. */
147 struct file *cap_file; /* Back-pointer to cap's file. */
148 cap_rights_t cap_rights; /* Mask of rights on object. */
149 };
150
151 /*
152 * Capabilities have a fileops vector, but in practice none should ever be
153 * called except for fo_close, as the capability will normally not be
154 * returned during a file descriptor lookup in the system call code.
155 */
156 static fo_rdwr_t capability_read;
157 static fo_rdwr_t capability_write;
158 static fo_truncate_t capability_truncate;
159 static fo_ioctl_t capability_ioctl;
160 static fo_poll_t capability_poll;
161 static fo_kqfilter_t capability_kqfilter;
162 static fo_stat_t capability_stat;
163 static fo_close_t capability_close;
164 static fo_chmod_t capability_chmod;
165 static fo_chown_t capability_chown;
166
167 static struct fileops capability_ops = {
168 .fo_read = capability_read,
169 .fo_write = capability_write,
170 .fo_truncate = capability_truncate,
171 .fo_ioctl = capability_ioctl,
172 .fo_poll = capability_poll,
173 .fo_kqfilter = capability_kqfilter,
174 .fo_stat = capability_stat,
175 .fo_close = capability_close,
176 .fo_chmod = capability_chmod,
177 .fo_chown = capability_chown,
178 .fo_flags = DFLAG_PASSABLE,
179 };
180
181 static struct fileops capability_ops_unpassable = {
182 .fo_read = capability_read,
183 .fo_write = capability_write,
184 .fo_truncate = capability_truncate,
185 .fo_ioctl = capability_ioctl,
186 .fo_poll = capability_poll,
187 .fo_kqfilter = capability_kqfilter,
188 .fo_stat = capability_stat,
189 .fo_close = capability_close,
190 .fo_chmod = capability_chmod,
191 .fo_chown = capability_chown,
192 .fo_flags = 0,
193 };
194
195 static uma_zone_t capability_zone;
196
197 static void
198 capability_init(void *dummy __unused)
199 {
200
201 capability_zone = uma_zcreate("capability", sizeof(struct capability),
202 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
203 if (capability_zone == NULL)
204 panic("capability_init: capability_zone not initialized");
205 }
206 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_ANY, capability_init, NULL);
207
208 /*
209 * Test whether a capability grants the requested rights.
210 */
211 static int
212 cap_check(struct capability *c, cap_rights_t rights)
213 {
214
215 if ((c->cap_rights | rights) != c->cap_rights)
216 return (ENOTCAPABLE);
217 return (0);
218 }
219
220 /*
221 * Extract rights from a capability for monitoring purposes -- not for use in
222 * any other way, as we want to keep all capability permission evaluation in
223 * this one file.
224 */
225 cap_rights_t
226 cap_rights(struct file *fp_cap)
227 {
228 struct capability *c;
229
230 KASSERT(fp_cap->f_type == DTYPE_CAPABILITY,
231 ("cap_rights: !capability"));
232
233 c = fp_cap->f_data;
234 return (c->cap_rights);
235 }
236
237 /*
238 * System call to create a new capability reference to either an existing
239 * file object or an an existing capability.
240 */
241 int
242 sys_cap_new(struct thread *td, struct cap_new_args *uap)
243 {
244 int error, capfd;
245 int fd = uap->fd;
246 struct file *fp;
247 cap_rights_t rights = uap->rights;
248
249 AUDIT_ARG_FD(fd);
250 AUDIT_ARG_RIGHTS(rights);
251 error = fget(td, fd, rights, &fp);
252 if (error)
253 return (error);
254 AUDIT_ARG_FILE(td->td_proc, fp);
255 error = kern_capwrap(td, fp, rights, &capfd);
256 if (error)
257 return (error);
258
259 /*
260 * Release our reference to the file (kern_capwrap has held a reference
261 * for the filedesc array).
262 */
263 fdrop(fp, td);
264 td->td_retval[0] = capfd;
265 return (0);
266 }
267
268 /*
269 * System call to query the rights mask associated with a capability.
270 */
271 int
272 sys_cap_getrights(struct thread *td, struct cap_getrights_args *uap)
273 {
274 struct capability *cp;
275 struct file *fp;
276 int error;
277
278 AUDIT_ARG_FD(uap->fd);
279 error = fgetcap(td, uap->fd, &fp);
280 if (error)
281 return (error);
282 cp = fp->f_data;
283 error = copyout(&cp->cap_rights, uap->rightsp, sizeof(*uap->rightsp));
284 fdrop(fp, td);
285 return (error);
286 }
287
288 /*
289 * Create a capability to wrap around an existing file.
290 */
291 int
292 kern_capwrap(struct thread *td, struct file *fp, cap_rights_t rights,
293 int *capfdp)
294 {
295 struct capability *cp, *cp_old;
296 struct file *fp_object, *fcapp;
297 int error;
298
299 if ((rights | CAP_MASK_VALID) != CAP_MASK_VALID)
300 return (EINVAL);
301
302 /*
303 * If a new capability is being derived from an existing capability,
304 * then the new capability rights must be a subset of the existing
305 * rights.
306 */
307 if (fp->f_type == DTYPE_CAPABILITY) {
308 cp_old = fp->f_data;
309 if ((cp_old->cap_rights | rights) != cp_old->cap_rights)
310 return (ENOTCAPABLE);
311 }
312
313 /*
314 * Allocate a new file descriptor to hang the capability off of.
315 */
316 error = falloc(td, &fcapp, capfdp, fp->f_flag);
317 if (error)
318 return (error);
319
320 /*
321 * Rather than nesting capabilities, directly reference the object an
322 * existing capability references. There's nothing else interesting
323 * to preserve for future use, as we've incorporated the previous
324 * rights mask into the new one. This prevents us from having to
325 * deal with capability chains.
326 */
327 if (fp->f_type == DTYPE_CAPABILITY)
328 fp_object = ((struct capability *)fp->f_data)->cap_object;
329 else
330 fp_object = fp;
331 fhold(fp_object);
332 cp = uma_zalloc(capability_zone, M_WAITOK | M_ZERO);
333 cp->cap_rights = rights;
334 cp->cap_object = fp_object;
335 cp->cap_file = fcapp;
336 if (fp->f_flag & DFLAG_PASSABLE)
337 finit(fcapp, fp->f_flag, DTYPE_CAPABILITY, cp,
338 &capability_ops);
339 else
340 finit(fcapp, fp->f_flag, DTYPE_CAPABILITY, cp,
341 &capability_ops_unpassable);
342
343 /*
344 * Release our private reference (the proc filedesc still has one).
345 */
346 fdrop(fcapp, td);
347 return (0);
348 }
349
350 /*
351 * Given a file descriptor, test it against a capability rights mask and then
352 * return the file descriptor on which to actually perform the requested
353 * operation. As long as the reference to fp_cap remains valid, the returned
354 * pointer in *fp will remain valid, so no extra reference management is
355 * required, and the caller should fdrop() fp_cap as normal when done with
356 * both.
357 */
358 int
359 cap_funwrap(struct file *fp_cap, cap_rights_t rights, struct file **fpp)
360 {
361 struct capability *c;
362 int error;
363
364 if (fp_cap->f_type != DTYPE_CAPABILITY) {
365 *fpp = fp_cap;
366 return (0);
367 }
368 c = fp_cap->f_data;
369 error = cap_check(c, rights);
370 if (error)
371 return (error);
372 *fpp = c->cap_object;
373 return (0);
374 }
375
376 /*
377 * Slightly different routine for memory mapping file descriptors: unwrap the
378 * capability and check CAP_MMAP, but also return a bitmask representing the
379 * maximum mapping rights the capability allows on the object.
380 */
381 int
382 cap_funwrap_mmap(struct file *fp_cap, cap_rights_t rights, u_char *maxprotp,
383 struct file **fpp)
384 {
385 struct capability *c;
386 u_char maxprot;
387 int error;
388
389 if (fp_cap->f_type != DTYPE_CAPABILITY) {
390 *fpp = fp_cap;
391 *maxprotp = VM_PROT_ALL;
392 return (0);
393 }
394 c = fp_cap->f_data;
395 error = cap_check(c, rights | CAP_MMAP);
396 if (error)
397 return (error);
398 *fpp = c->cap_object;
399 maxprot = 0;
400 if (c->cap_rights & CAP_READ)
401 maxprot |= VM_PROT_READ;
402 if (c->cap_rights & CAP_WRITE)
403 maxprot |= VM_PROT_WRITE;
404 if (c->cap_rights & CAP_MAPEXEC)
405 maxprot |= VM_PROT_EXECUTE;
406 *maxprotp = maxprot;
407 return (0);
408 }
409
410 /*
411 * When a capability is closed, simply drop the reference on the underlying
412 * object and free the capability. fdrop() will handle the case where the
413 * underlying object also needs to close, and the caller will have already
414 * performed any object-specific lock or mqueue handling.
415 */
416 static int
417 capability_close(struct file *fp, struct thread *td)
418 {
419 struct capability *c;
420 struct file *fp_object;
421
422 KASSERT(fp->f_type == DTYPE_CAPABILITY,
423 ("capability_close: !capability"));
424
425 c = fp->f_data;
426 fp->f_ops = &badfileops;
427 fp->f_data = NULL;
428 fp_object = c->cap_object;
429 uma_zfree(capability_zone, c);
430 return (fdrop(fp_object, td));
431 }
432
433 /*
434 * In general, file descriptor operations should never make it to the
435 * capability, only the underlying file descriptor operation vector, so panic
436 * if we do turn up here.
437 */
438 static int
439 capability_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
440 int flags, struct thread *td)
441 {
442
443 panic("capability_read");
444 }
445
446 static int
447 capability_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
448 int flags, struct thread *td)
449 {
450
451 panic("capability_write");
452 }
453
454 static int
455 capability_truncate(struct file *fp, off_t length, struct ucred *active_cred,
456 struct thread *td)
457 {
458
459 panic("capability_truncate");
460 }
461
462 static int
463 capability_ioctl(struct file *fp, u_long com, void *data,
464 struct ucred *active_cred, struct thread *td)
465 {
466
467 panic("capability_ioctl");
468 }
469
470 static int
471 capability_poll(struct file *fp, int events, struct ucred *active_cred,
472 struct thread *td)
473 {
474
475 panic("capability_poll");
476 }
477
478 static int
479 capability_kqfilter(struct file *fp, struct knote *kn)
480 {
481
482 panic("capability_kqfilter");
483 }
484
485 static int
486 capability_stat(struct file *fp, struct stat *sb, struct ucred *active_cred,
487 struct thread *td)
488 {
489
490 panic("capability_stat");
491 }
492
493 int
494 capability_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
495 struct thread *td)
496 {
497
498 panic("capability_chmod");
499 }
500
501 int
502 capability_chown(struct file *fp, uid_t uid, gid_t gid,
503 struct ucred *active_cred, struct thread *td)
504 {
505
506 panic("capability_chown");
507 }
508
509 #else /* !CAPABILITIES */
510
511 /*
512 * Stub Capability functions for when options CAPABILITIES isn't compiled
513 * into the kernel.
514 */
515 int
516 sys_cap_new(struct thread *td, struct cap_new_args *uap)
517 {
518
519 return (ENOSYS);
520 }
521
522 int
523 sys_cap_getrights(struct thread *td, struct cap_getrights_args *uap)
524 {
525
526 return (ENOSYS);
527 }
528
529 int
530 cap_funwrap(struct file *fp_cap, cap_rights_t rights, struct file **fpp)
531 {
532
533 KASSERT(fp_cap->f_type != DTYPE_CAPABILITY,
534 ("cap_funwrap: saw capability"));
535
536 *fpp = fp_cap;
537 return (0);
538 }
539
540 int
541 cap_funwrap_mmap(struct file *fp_cap, cap_rights_t rights, u_char *maxprotp,
542 struct file **fpp)
543 {
544
545 KASSERT(fp_cap->f_type != DTYPE_CAPABILITY,
546 ("cap_funwrap_mmap: saw capability"));
547
548 *fpp = fp_cap;
549 *maxprotp = VM_PROT_ALL;
550 return (0);
551 }
552
553 #endif /* CAPABILITIES */
Cache object: 920bcc337a4bb98dca34c1eda451c434
|