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/security/mac_internal.h

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) 2007 Apple Inc. All rights reserved.
    3  *
    4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
    5  * 
    6  * This file contains Original Code and/or Modifications of Original Code
    7  * as defined in and that are subject to the Apple Public Source License
    8  * Version 2.0 (the 'License'). You may not use this file except in
    9  * compliance with the License. The rights granted to you under the License
   10  * may not be used to create, or enable the creation or redistribution of,
   11  * unlawful or unlicensed copies of an Apple operating system, or to
   12  * circumvent, violate, or enable the circumvention or violation of, any
   13  * terms of an Apple operating system software license agreement.
   14  * 
   15  * Please obtain a copy of the License at
   16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
   17  * 
   18  * The Original Code and all software distributed under the License are
   19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
   20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
   21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
   22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
   23  * Please see the License for the specific language governing rights and
   24  * limitations under the License.
   25  * 
   26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
   27  */
   28 
   29 /*-
   30  * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson
   31  * Copyright (c) 2001 Ilmar S. Habibulin
   32  * Copyright (c) 2001, 2002, 2003, 2004 Networks Associates Technology, Inc.
   33  * Copyright (c) 2005 SPARTA, Inc.
   34  * All rights reserved.
   35  *
   36  * This software was developed by Robert Watson and Ilmar Habibulin for the
   37  * TrustedBSD Project.
   38  *
   39  * This software was developed for the FreeBSD Project in part by Network
   40  * Associates Laboratories, the Security Research Division of Network
   41  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"),
   42  * as part of the DARPA CHATS research program.
   43  *
   44  * Redistribution and use in source and binary forms, with or without
   45  * modification, are permitted provided that the following conditions
   46  * are met:
   47  * 1. Redistributions of source code must retain the above copyright
   48  *    notice, this list of conditions and the following disclaimer.
   49  * 2. Redistributions in binary form must reproduce the above copyright
   50  *    notice, this list of conditions and the following disclaimer in the
   51  *    documentation and/or other materials provided with the distribution.
   52  *
   53  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   63  * SUCH DAMAGE.
   64  *
   65  */
   66 
   67 #ifndef _SECURITY_MAC_INTERNAL_H_
   68 #define _SECURITY_MAC_INTERNAL_H_
   69 
   70 #include <string.h>
   71 #include <sys/param.h>
   72 #include <sys/queue.h>
   73 #include <security/mac.h>
   74 #include <security/mac_framework.h>
   75 #include <security/mac_policy.h>
   76 #include <security/mac_data.h>
   77 #include <sys/sysctl.h>
   78 #include <kern/wait_queue.h>
   79 #include <kern/locks.h>
   80 #include <sys/kernel.h>
   81 #include <sys/lock.h>
   82 #include <sys/malloc.h>
   83 #include <sys/sbuf.h>
   84 #include <sys/proc.h>
   85 #include <sys/systm.h>
   86 #include <sys/socket.h>
   87 #include <sys/socketvar.h>
   88 #include <sys/vnode.h>
   89 
   90 /*
   91  * MAC Framework sysctl namespace.
   92  */
   93 
   94 SYSCTL_DECL(_security);
   95 SYSCTL_DECL(_security_mac);
   96 
   97 extern int mac_late;
   98 
   99 struct mac_policy_list_element {
  100         struct mac_policy_conf *mpc;
  101 };    
  102 
  103 struct mac_policy_list {
  104         u_int                           numloaded;
  105         u_int                           max;
  106         u_int                           maxindex;
  107         u_int                           staticmax;
  108         u_int                           chunks;
  109         u_int                           freehint;
  110         struct mac_policy_list_element  *entries;
  111 };
  112 
  113 typedef struct mac_policy_list mac_policy_list_t;
  114 
  115 
  116 /*
  117  * Policy that has registered with the framework for a specific
  118  * label namespace name.
  119  */
  120 struct mac_label_listener {
  121         mac_policy_handle_t             mll_handle;
  122         LIST_ENTRY(mac_label_listener)  mll_list;
  123 };
  124 
  125 LIST_HEAD(mac_label_listeners_t, mac_label_listener);
  126 
  127 /* 
  128  * Type of list used to manage label namespace names.
  129  */   
  130 struct mac_label_element {
  131         char                            mle_name[MAC_MAX_LABEL_ELEMENT_NAME];
  132         struct mac_label_listeners_t    mle_listeners;
  133         LIST_ENTRY(mac_label_element)   mle_list;
  134 };
  135 
  136 LIST_HEAD(mac_label_element_list_t, mac_label_element);
  137 
  138 /*
  139  * Journal operations
  140  */
  141 
  142 #define MLJ_TYPE_PORT           1
  143 #define MLJ_TYPE_TASK           2
  144 
  145 #define MLJ_PORT_OP_INIT        0x0001
  146 #define MLJ_PORT_OP_CREATE_K    0x0002
  147 #define MLJ_PORT_OP_CREATE      0x0004
  148 #define MLJ_PORT_OP_UPDATE      0x0008
  149 
  150 #define MLJ_TASK_OP_INIT        0x0001
  151 #define MLJ_TASK_OP_CREATE_K    0x0002
  152 
  153 struct mac_label_journal {
  154         struct label *l;
  155         int type;
  156         int ops;
  157 
  158         int kotype;     /* Kernel Port */
  159 
  160         TAILQ_ENTRY(mac_label_journal) link;
  161 };
  162 TAILQ_HEAD(mac_label_journal_list_t, mac_label_journal);
  163 
  164 int     mac_label_journal_add   (struct label *, int);
  165 int     mac_label_journal_remove(struct label *);
  166 struct mac_label_journal *
  167         mac_label_journal_find  (struct label *);
  168 int     mac_label_journal       (struct label *, int, ...);
  169 void    mac_label_journal_replay(void);
  170 
  171 
  172 /*
  173  * MAC Framework global variables.
  174  */
  175 
  176 extern struct mac_label_element_list_t mac_label_element_list;
  177 extern struct mac_label_element_list_t mac_static_label_element_list;
  178 extern struct mac_label_journal_list_t mac_label_journal_list;
  179 
  180 extern struct mac_policy_list mac_policy_list;
  181 
  182 /*
  183  * global flags to control whether a MACF subsystem is configured
  184  * at all in the system.
  185  */
  186 extern unsigned int mac_device_enforce;
  187 extern unsigned int mac_pipe_enforce;
  188 extern unsigned int mac_posixsem_enforce;
  189 extern unsigned int mac_posixshm_enforce;
  190 extern unsigned int mac_proc_enforce;
  191 extern unsigned int mac_socket_enforce;
  192 extern unsigned int mac_system_enforce;
  193 extern unsigned int mac_sysvmsg_enforce;
  194 extern unsigned int mac_sysvsem_enforce;
  195 extern unsigned int mac_sysvshm_enforce;
  196 extern unsigned int mac_vm_enforce;
  197 extern unsigned int mac_vnode_enforce;
  198 
  199 #if CONFIG_MACF_NET
  200 extern unsigned int mac_label_mbufs;
  201 #endif
  202 
  203 extern unsigned int mac_label_vnodes;
  204 
  205 static int mac_proc_check_enforce(proc_t p, int enforce_flag);
  206 
  207 static __inline__ int mac_proc_check_enforce(proc_t p, int enforce_flags)
  208 {
  209 #if CONFIG_MACF
  210         return ((p->p_mac_enforce & enforce_flags) != 0);
  211 #else
  212         return 0;
  213 #endif
  214 }
  215 
  216 static int mac_context_check_enforce(vfs_context_t ctx, int enforce_flags);
  217 static void mac_context_set_enforce(vfs_context_t ctx, int enforce_flags);
  218 
  219 static __inline__ int mac_context_check_enforce(vfs_context_t ctx, int enforce_flags)
  220 {
  221         proc_t proc = vfs_context_proc(ctx);
  222 
  223         if (proc == NULL)
  224                 return 0;
  225 
  226         return (mac_proc_check_enforce(proc, enforce_flags));
  227 }
  228 
  229 static __inline__ void mac_context_set_enforce(vfs_context_t ctx, int enforce_flags)
  230 {
  231         proc_t proc = vfs_context_proc(ctx);
  232 
  233         if (proc == NULL)
  234                 return;
  235 
  236         mac_proc_set_enforce(proc, enforce_flags);
  237 }
  238 
  239 
  240 /*
  241  * MAC Framework infrastructure functions.
  242  */
  243 
  244 int mac_error_select(int error1, int error2);
  245 
  246 void  mac_policy_list_busy(void);
  247 int   mac_policy_list_conditional_busy(void);
  248 void  mac_policy_list_unbusy(void);
  249 
  250 void           mac_labelzone_init(void);
  251 struct label  *mac_labelzone_alloc(int flags);
  252 void           mac_labelzone_free(struct label *label);
  253 
  254 void  mac_label_init(struct label *label);
  255 void  mac_label_destroy(struct label *label);
  256 #if KERNEL
  257 int   mac_check_structmac_consistent(struct user_mac *mac);
  258 #else
  259 int   mac_check_structmac_consistent(struct mac *mac);
  260 #endif
  261         
  262 int mac_cred_label_externalize(struct label *, char *e, char *out, size_t olen, int flags);
  263 int mac_lctx_label_externalize(struct label *, char *e, char *out, size_t olen);
  264 #if CONFIG_MACF_SOCKET
  265 int mac_socket_label_externalize(struct label *, char *e, char *out, size_t olen);
  266 #endif /* CONFIG_MACF_SOCKET */
  267 int mac_vnode_label_externalize(struct label *, char *e, char *out, size_t olen, int flags);
  268 int mac_pipe_label_externalize(struct label *label, char *elements,
  269  char *outbuf, size_t outbuflen);
  270 
  271 int mac_cred_label_internalize(struct label *label, char *string);
  272 int mac_lctx_label_internalize(struct label *label, char *string);
  273 #if CONFIG_MACF_SOCKET
  274 int mac_socket_label_internalize(struct label *label, char *string);
  275 #endif /* CONFIG_MACF_SOCKET */
  276 int mac_vnode_label_internalize(struct label *label, char *string);
  277 int mac_pipe_label_internalize(struct label *label, char *string);
  278 
  279 #if CONFIG_MACF_SOCKET
  280 /* internal socket label manipulation functions */
  281 struct  label *mac_socket_label_alloc(int flags);
  282 void    mac_socket_label_free(struct label *l);
  283 int     mac_socket_label_update(struct ucred *cred, struct socket *so, struct label *l);
  284 #endif /* MAC_SOCKET */
  285 
  286 #if CONFIG_MACF_NET
  287 struct label *mac_mbuf_to_label(struct mbuf *m);
  288 #else
  289 #define mac_mbuf_to_label(m) (NULL)
  290 #endif
  291 
  292 /*
  293  * MAC_CHECK performs the designated check by walking the policy
  294  * module list and checking with each as to how it feels about the
  295  * request.  Note that it returns its value via 'error' in the scope
  296  * of the caller.
  297  */
  298 #define MAC_CHECK(check, args...) do {                                  \
  299         struct mac_policy_conf *mpc;                                    \
  300         u_int i;                                                        \
  301                                                                         \
  302         error = 0;                                                      \
  303         for (i = 0; i < mac_policy_list.staticmax; i++) {               \
  304                 mpc = mac_policy_list.entries[i].mpc;                   \
  305                 if (mpc == NULL)                                        \
  306                         continue;                                       \
  307                                                                         \
  308                 if (mpc->mpc_ops->mpo_ ## check != NULL)                \
  309                         error = mac_error_select(                       \
  310                             mpc->mpc_ops->mpo_ ## check (args),         \
  311                             error);                                     \
  312         }                                                               \
  313         if (mac_policy_list_conditional_busy() != 0) {                  \
  314                 for (; i <= mac_policy_list.maxindex; i++) {            \
  315                         mpc = mac_policy_list.entries[i].mpc;           \
  316                         if (mpc == NULL)                                \
  317                                 continue;                               \
  318                                                                         \
  319                         if (mpc->mpc_ops->mpo_ ## check != NULL)        \
  320                                 error = mac_error_select(               \
  321                                     mpc->mpc_ops->mpo_ ## check (args), \
  322                                     error);                             \
  323                 }                                                       \
  324                 mac_policy_list_unbusy();                               \
  325         }                                                               \
  326 } while (0)
  327 
  328 /*
  329  * MAC_GRANT performs the designated check by walking the policy
  330  * module list and checking with each as to how it feels about the
  331  * request.  Unlike MAC_CHECK, it grants if any policies return '',
  332  * and otherwise returns EPERM.  Note that it returns its value via
  333  * 'error' in the scope of the caller.
  334  */
  335 #define MAC_GRANT(check, args...) do {                                  \
  336         struct mac_policy_conf *mpc;                                    \
  337         u_int i;                                                        \
  338                                                                         \
  339         error = EPERM;                                                  \
  340         for (i = 0; i < mac_policy_list.staticmax; i++) {               \
  341                 mpc = mac_policy_list.entries[i].mpc;                   \
  342                 if (mpc == NULL)                                        \
  343                         continue;                                       \
  344                                                                         \
  345                 if (mpc->mpc_ops->mpo_ ## check != NULL) {              \
  346                         if (mpc->mpc_ops->mpo_ ## check (args) == 0)    \
  347                                 error = 0;                              \
  348                 }                                                       \
  349         }                                                               \
  350         if (mac_policy_list_conditional_busy() != 0) {                  \
  351                 for (; i <= mac_policy_list.maxindex; i++) {            \
  352                         mpc = mac_policy_list.entries[i].mpc;           \
  353                         if (mpc == NULL)                                \
  354                                 continue;                               \
  355                                                                         \
  356                         if (mpc->mpc_ops->mpo_ ## check != NULL) {      \
  357                                 if (mpc->mpc_ops->mpo_ ## check (args)  \
  358                                     == 0)                               \
  359                                         error = 0;                      \
  360                         }                                               \
  361                 }                                                       \
  362                 mac_policy_list_unbusy();                               \
  363         }                                                               \
  364 } while (0)
  365 
  366 /*
  367  * MAC_BOOLEAN performs the designated boolean composition by walking
  368  * the module list, invoking each instance of the operation, and
  369  * combining the results using the passed C operator.  Note that it
  370  * returns its value via 'result' in the scope of the caller, which
  371  * should be initialized by the caller in a meaningful way to get
  372  * a meaningful result.
  373  */
  374 #define MAC_BOOLEAN(operation, composition, args...) do {               \
  375         struct mac_policy_conf *mpc;                                    \
  376         u_int i;                                                        \
  377                                                                         \
  378         for (i = 0; i < mac_policy_list.staticmax; i++) {               \
  379                 mpc = mac_policy_list.entries[i].mpc;                   \
  380                 if (mpc == NULL)                                        \
  381                         continue;                                       \
  382                                                                         \
  383                 if (mpc->mpc_ops->mpo_ ## operation != NULL)            \
  384                         result = result composition                     \
  385                             mpc->mpc_ops->mpo_ ## operation             \
  386                             (args);                                     \
  387         }                                                               \
  388         if (mac_policy_list_conditional_busy() != 0) {                  \
  389                 for (; i <= mac_policy_list.maxindex; i++) {            \
  390                         mpc = mac_policy_list.entries[i].mpc;           \
  391                         if (mpc == NULL)                                \
  392                                 continue;                               \
  393                                                                         \
  394                         if (mpc->mpc_ops->mpo_ ## operation != NULL)    \
  395                                 result = result composition             \
  396                                     mpc->mpc_ops->mpo_ ## operation     \
  397                                     (args);                             \
  398                 }                                                       \
  399                 mac_policy_list_unbusy();                               \
  400         }                                                               \
  401 } while (0)
  402 
  403 #define MAC_INTERNALIZE(obj, label, instring)                           \
  404         mac_internalize(offsetof(struct mac_policy_ops, mpo_ ## obj ## _label_internalize), label, instring)
  405 
  406 #define MAC_EXTERNALIZE(obj, label, elementlist, outbuf, outbuflen)     \
  407         mac_externalize(offsetof(struct mac_policy_ops, mpo_ ## obj ## _label_externalize), label, elementlist, outbuf, outbuflen)
  408 
  409 #define MAC_EXTERNALIZE_AUDIT(obj, label, outbuf, outbuflen)    \
  410         mac_externalize(offsetof(struct mac_policy_ops, mpo_ ## obj ## _label_externalize_audit), label, "*", outbuf, outbuflen)
  411 
  412 /*
  413  * MAC_PERFORM performs the designated operation by walking the policy
  414  * module list and invoking that operation for each policy.
  415  */
  416 #define MAC_PERFORM(operation, args...) do {                            \
  417         struct mac_policy_conf *mpc;                                    \
  418         u_int i;                                                        \
  419                                                                         \
  420         for (i = 0; i < mac_policy_list.staticmax; i++) {               \
  421                 mpc = mac_policy_list.entries[i].mpc;                   \
  422                 if (mpc == NULL)                                        \
  423                         continue;                                       \
  424                                                                         \
  425                 if (mpc->mpc_ops->mpo_ ## operation != NULL)            \
  426                         mpc->mpc_ops->mpo_ ## operation (args);         \
  427         }                                                               \
  428         if (mac_policy_list_conditional_busy() != 0) {                  \
  429                 for (; i <= mac_policy_list.maxindex; i++) {            \
  430                         mpc = mac_policy_list.entries[i].mpc;           \
  431                         if (mpc == NULL)                                \
  432                                 continue;                               \
  433                                                                         \
  434                         if (mpc->mpc_ops->mpo_ ## operation != NULL)    \
  435                                 mpc->mpc_ops->mpo_ ## operation (args); \
  436                 }                                                       \
  437                 mac_policy_list_unbusy();                               \
  438         }                                                               \
  439 } while (0)
  440 
  441 struct __mac_get_pid_args;
  442 struct __mac_get_proc_args;
  443 struct __mac_set_proc_args;
  444 struct __mac_get_lcid_args;
  445 struct __mac_get_lctx_args;
  446 struct __mac_set_lctx_args;
  447 struct __mac_get_fd_args;
  448 struct __mac_get_file_args;
  449 struct __mac_get_link_args;
  450 struct __mac_set_fd_args;
  451 struct __mac_set_file_args;
  452 struct __mac_syscall_args;
  453 
  454 void mac_policy_addto_labellist(const mac_policy_handle_t, int);
  455 void mac_policy_removefrom_labellist(const mac_policy_handle_t);
  456 
  457 int mac_externalize(size_t mpo_externalize_off, struct label *label,
  458     const char *elementlist, char *outbuf, size_t outbuflen);
  459 int mac_internalize(size_t mpo_internalize_off, struct label *label,
  460     char *elementlist);
  461 #endif  /* !_SECURITY_MAC_INTERNAL_H_ */

Cache object: d7a7b6016c3d5d98d1df08495e76489b


[ 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.