The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/sys_capability.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.