security/mac_mach.c

   1 /*
   2  * Copyright (c) 2015 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 #include <mach/exception_types.h>
  30 #include <mach/mach_types.h>
  31 #include <osfmk/kern/exception.h>
  32 #include <osfmk/kern/task.h>
  33 #include <sys/codesign.h>
  34 #include <sys/param.h>
  35 #include <sys/user.h>
  36 #include <sys/proc.h>
  37 #include <sys/proc_internal.h>
  38 #include <sys/kauth.h>
  39 #include <kern/task.h>
  40
  41 #include <security/mac_framework.h>
  42 #include <security/mac_internal.h>
  43 #include <security/mac_mach_internal.h>
  44
  45 #if CONFIG_CSR
  46 #include <sys/csr.h>
  47 // Panic on internal builds, just log otherwise.
  48 #define MAC_MACH_UNEXPECTED(fmt...) \
  49         if (csr_check(CSR_ALLOW_APPLE_INTERNAL) == 0) { panic(fmt); } else { printf(fmt); }
  50 #else
  51 #define MAC_MACH_UNEXPECTED(fmt...) printf(fmt)
  52 #endif
  53
  54 static struct proc *
  55 mac_task_get_proc(struct task *task)
  56 {
  57         if (task == current_task())
  58                 return proc_self();
  59
  60         /*
  61          * Tasks don't really hold a reference on a proc unless the
  62          * calling thread belongs to the task in question.
  63          */
  64         int pid = task_pid(task);
  65         struct proc *p = proc_find(pid);
  66
  67         if (p != NULL) {
  68                 if (proc_task(p) == task)
  69                         return p;
  70                 proc_rele(p);
  71         }
  72         return NULL;
  73 }
  74
  75 int
  76 mac_task_check_expose_task(struct task *task)
  77 {
  78         int error;
  79
  80         struct proc *p = mac_task_get_proc(task);
  81         if (p == NULL)
  82                 return ESRCH;
  83
  84         struct ucred *cred = kauth_cred_get();
  85         MAC_CHECK(proc_check_expose_task, cred, p);
  86         proc_rele(p);
  87         return (error);
  88 }
  89
  90 int
  91 mac_task_check_set_host_special_port(struct task *task, int id, struct ipc_port *port)
  92 {
  93         int error;
  94
  95         struct proc *p = mac_task_get_proc(task);
  96         if (p == NULL)
  97                 return ESRCH;
  98
  99         kauth_cred_t cred = kauth_cred_proc_ref(p);
 100         MAC_CHECK(proc_check_set_host_special_port, cred, id, port);
 101         kauth_cred_unref(&cred);
 102         proc_rele(p);
 103         return (error);
 104 }
 105
 106 int
 107 mac_task_check_set_host_exception_port(struct task *task, unsigned int exception)
 108 {
 109         int error;
 110
 111         struct proc *p = mac_task_get_proc(task);
 112         if (p == NULL)
 113                 return ESRCH;
 114
 115         kauth_cred_t cred = kauth_cred_proc_ref(p);
 116         MAC_CHECK(proc_check_set_host_exception_port, cred, exception);
 117         kauth_cred_unref(&cred);
 118         proc_rele(p);
 119         return (error);
 120 }
 121
 122 int
 123 mac_task_check_set_host_exception_ports(struct task *task, unsigned int exception_mask)
 124 {
 125         int error = 0;
 126         int exception;
 127
 128         struct proc *p = mac_task_get_proc(task);
 129         if (p == NULL)
 130                 return ESRCH;
 131
 132         kauth_cred_t cred = kauth_cred_proc_ref(p);
 133         for (exception = FIRST_EXCEPTION; exception < EXC_TYPES_COUNT; exception++) {
 134                 if (exception_mask & (1 << exception)) {
 135                         MAC_CHECK(proc_check_set_host_exception_port, cred, exception);
 136                         if (error)
 137                                 break;
 138                 }
 139         }
 140         kauth_cred_unref(&cred);
 141         proc_rele(p);
 142         return (error);
 143 }
 144
 145 void
 146 mac_thread_userret(struct thread *td)
 147 {
 148
 149         MAC_PERFORM(thread_userret, td);
 150 }
 151
 152 /**** Exception Policy
 153  *
 154  * Note that the functions below do not fully follow the usual convention for mac policy functions
 155  * in the kernel. Besides avoiding confusion in how the mac function names are mixed with the actual
 156  * policy function names, we diverge because the exception policy is somewhat special:
 157  * It is used in places where allocation and association must be separate, and its labels do not
 158  * only belong to one type of object as usual, but to two (on exception actions and on tasks as
 159  * crash labels).
 160  */
 161
 162 // Label allocation and deallocation, may sleep.
 163
 164 struct label *
 165 mac_exc_create_label(void)
 166 {
 167         struct label *label = mac_labelzone_alloc(MAC_WAITOK);
 168
 169         if (label == NULL) {
 170                 return NULL;
 171         }
 172
 173         // Policy initialization of the label, typically performs allocations as well.
 174         // (Unless the policy's full data really fits into a pointer size.)
 175         MAC_PERFORM(exc_action_label_init, label);
 176
 177         return label;
 178 }
 179
 180 void
 181 mac_exc_free_label(struct label *label)
 182 {
 183         MAC_PERFORM(exc_action_label_destroy, label);
 184         mac_labelzone_free(label);
 185 }
 186
 187 // Action label initialization and teardown, may sleep.
 188
 189 void
 190 mac_exc_associate_action_label(struct exception_action *action, struct label *label)
 191 {
 192         action->label = label;
 193         MAC_PERFORM(exc_action_label_associate, action, action->label);
 194 }
 195
 196 void
 197 mac_exc_free_action_label(struct exception_action *action)
 198 {
 199         mac_exc_free_label(action->label);
 200         action->label = NULL;
 201 }
 202
 203 // Action label update and inheritance, may NOT sleep and must be quick.
 204
 205 int
 206 mac_exc_update_action_label(struct exception_action *action,
 207                                                         struct label *newlabel) {
 208         int error;
 209
 210         MAC_CHECK(exc_action_label_update, action, action->label, newlabel);
 211
 212         return (error);
 213 }
 214
 215 int
 216 mac_exc_inherit_action_label(struct exception_action *parent,
 217                                                          struct exception_action *child) {
 218         return mac_exc_update_action_label(child, parent->label);
 219 }
 220
 221 int mac_exc_update_task_crash_label(struct task *task, struct label *label) {
 222         int error;
 223
 224         assert(task != kernel_task);
 225
 226         struct label *crash_label = get_task_crash_label(task);
 227
 228         MAC_CHECK(exc_action_label_update, NULL, crash_label, label);
 229
 230         return (error);
 231 }
 232
 233 // Process label creation, may sleep.
 234
 235 struct label *
 236 mac_exc_create_label_for_proc(struct proc *proc)
 237 {
 238         struct label *label = mac_exc_create_label();
 239         MAC_PERFORM(exc_action_label_populate, label, proc);
 240         return label;
 241 }
 242
 243 struct label *
 244 mac_exc_create_label_for_current_proc(void)
 245 {
 246         return mac_exc_create_label_for_proc(current_proc());
 247 }
 248
 249 // Exception handler policy checking, may sleep.
 250
 251 int
 252 mac_exc_action_check_exception_send(struct task *victim_task, struct exception_action *action)
 253 {
 254         int error = 0;
 255
 256         struct proc *p = get_bsdtask_info(victim_task);
 257         struct label *bsd_label = NULL;
 258         struct label *label = NULL;
 259
 260         if (p != NULL) {
 261                 // Create a label from the still existing bsd process...
 262                 label = bsd_label = mac_exc_create_label_for_proc(p);
 263         } else {
 264                 // ... otherwise use the crash label on the task.
 265                 label = get_task_crash_label(victim_task);
 266         }
 267
 268         if (label == NULL) {
 269                 MAC_MACH_UNEXPECTED("mac_exc_action_check_exception_send: no exc_action label for process");
 270                 return EPERM;
 271         }
 272
 273         MAC_CHECK(exc_action_check_exception_send, label, action, action->label);
 274
 275         if (bsd_label != NULL) {
 276                 mac_exc_free_label(bsd_label);
 277         }
 278
 279         return (error);
 280 }