bsd/security/audit/audit_arg.c

   1 /*-
   2  * Copyright (c) 1999-2016 Apple Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  25  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  26  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  */
  30 /*
  31  * NOTICE: This file was modified by McAfee Research in 2004 to introduce
  32  * support for mandatory and extensible security protections.  This notice
  33  * is included in support of clause 2.2 (b) of the Apple Public License,
  34  * Version 2.0.
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/kernel.h>
  40 #include <sys/lock.h>
  41 #include <sys/namei.h>
  42 #include <sys/proc_internal.h>
  43 #include <sys/kauth.h>
  44 #include <sys/queue.h>
  45 #include <sys/systm.h>
  46 #include <sys/time.h>
  47 #include <sys/ucred.h>
  48 #include <sys/uio.h>
  49 #include <sys/unistd.h>
  50 #include <sys/file_internal.h>
  51 #include <sys/vnode_internal.h>
  52 #include <sys/user.h>
  53 #include <sys/syscall.h>
  54 #include <sys/malloc.h>
  55 #include <sys/un.h>
  56 #include <sys/sysent.h>
  57 #include <sys/sysproto.h>
  58 #include <sys/vfs_context.h>
  59 #include <sys/domain.h>
  60 #include <sys/protosw.h>
  61 #include <sys/socketvar.h>
  62
  63 #include <bsm/audit.h>
  64 #include <bsm/audit_internal.h>
  65 #include <bsm/audit_kevents.h>
  66
  67 #include <security/audit/audit.h>
  68 #include <security/audit/audit_bsd.h>
  69 #include <security/audit/audit_private.h>
  70
  71 #include <mach/host_priv.h>
  72 #include <mach/host_special_ports.h>
  73 #include <mach/audit_triggers_server.h>
  74
  75 #include <kern/host.h>
  76 #include <kern/kalloc.h>
  77 #include <kern/zalloc.h>
  78 #include <kern/sched_prim.h>
  79
  80 #if CONFIG_MACF
  81 #include <bsm/audit_record.h>
  82 #include <security/mac.h>
  83 #include <security/mac_framework.h>
  84 #include <security/mac_policy.h>
  85 extern zone_t audit_mac_label_zone;
  86 #endif
  87
  88 #include <net/route.h>
  89
  90 #include <netinet/in.h>
  91 #include <netinet/in_pcb.h>
  92
  93 #if CONFIG_AUDIT
  94 /*
  95  * Calls to manipulate elements of the audit record structure from system
  96  * call code.  Macro wrappers will prevent this functions from being entered
  97  * if auditing is disabled, avoiding the function call cost.  We check the
  98  * thread audit record pointer anyway, as the audit condition could change,
  99  * and pre-selection may not have allocated an audit record for this event.
 100  *
 101  * XXXAUDIT: Should we assert, in each case, that this field of the record
 102  * hasn't already been filled in?
 103  */
 104 void
 105 audit_arg_addr(struct kaudit_record *ar, user_addr_t addr)
 106 {
 107         struct proc *p = current_proc();
 108
 109         ar->k_ar.ar_arg_addr = addr;
 110
 111         /*
 112          * If the process is 64-bit then flag the address as such.
 113          */
 114         if (proc_is64bit(p))
 115                 ARG_SET_VALID(ar, ARG_ADDR64);
 116         else
 117                 ARG_SET_VALID(ar, ARG_ADDR32);
 118 }
 119
 120 void
 121 audit_arg_exit(struct kaudit_record *ar, int status, int retval)
 122 {
 123
 124         ar->k_ar.ar_arg_exitstatus = status;
 125         ar->k_ar.ar_arg_exitretval = retval;
 126         ARG_SET_VALID(ar, ARG_EXIT);
 127 }
 128
 129 void
 130 audit_arg_len(struct kaudit_record *ar, user_size_t len)
 131 {
 132
 133         ar->k_ar.ar_arg_len = len;
 134         ARG_SET_VALID(ar, ARG_LEN);
 135 }
 136
 137 void
 138 audit_arg_fd2(struct kaudit_record *ar, int fd)
 139 {
 140
 141         ar->k_ar.ar_arg_fd2 = fd;
 142         ARG_SET_VALID(ar, ARG_FD2);
 143 }
 144
 145 void
 146 audit_arg_fd(struct kaudit_record *ar, int fd)
 147 {
 148
 149         ar->k_ar.ar_arg_fd = fd;
 150         ARG_SET_VALID(ar, ARG_FD);
 151 }
 152
 153 void
 154 audit_arg_fflags(struct kaudit_record *ar, int fflags)
 155 {
 156
 157         ar->k_ar.ar_arg_fflags = fflags;
 158         ARG_SET_VALID(ar, ARG_FFLAGS);
 159 }
 160
 161 void
 162 audit_arg_gid(struct kaudit_record *ar, gid_t gid)
 163 {
 164
 165         ar->k_ar.ar_arg_gid = gid;
 166         ARG_SET_VALID(ar, ARG_GID);
 167 }
 168
 169 void
 170 audit_arg_uid(struct kaudit_record *ar, uid_t uid)
 171 {
 172
 173         ar->k_ar.ar_arg_uid = uid;
 174         ARG_SET_VALID(ar, ARG_UID);
 175 }
 176
 177 void
 178 audit_arg_egid(struct kaudit_record *ar, gid_t egid)
 179 {
 180
 181         ar->k_ar.ar_arg_egid = egid;
 182         ARG_SET_VALID(ar, ARG_EGID);
 183 }
 184
 185 void
 186 audit_arg_euid(struct kaudit_record *ar, uid_t euid)
 187 {
 188
 189         ar->k_ar.ar_arg_euid = euid;
 190         ARG_SET_VALID(ar, ARG_EUID);
 191 }
 192
 193 void
 194 audit_arg_rgid(struct kaudit_record *ar, gid_t rgid)
 195 {
 196
 197         ar->k_ar.ar_arg_rgid = rgid;
 198         ARG_SET_VALID(ar, ARG_RGID);
 199 }
 200
 201 void
 202 audit_arg_ruid(struct kaudit_record *ar, uid_t ruid)
 203 {
 204
 205         ar->k_ar.ar_arg_ruid = ruid;
 206         ARG_SET_VALID(ar, ARG_RUID);
 207 }
 208
 209 void
 210 audit_arg_sgid(struct kaudit_record *ar, gid_t sgid)
 211 {
 212
 213         ar->k_ar.ar_arg_sgid = sgid;
 214         ARG_SET_VALID(ar, ARG_SGID);
 215 }
 216
 217 void
 218 audit_arg_suid(struct kaudit_record *ar, uid_t suid)
 219 {
 220
 221         ar->k_ar.ar_arg_suid = suid;
 222         ARG_SET_VALID(ar, ARG_SUID);
 223 }
 224
 225 void
 226 audit_arg_groupset(struct kaudit_record *ar, gid_t *gidset, u_int gidset_size)
 227 {
 228         u_int i;
 229
 230         for (i = 0; i < gidset_size; i++)
 231                 ar->k_ar.ar_arg_groups.gidset[i] = gidset[i];
 232         ar->k_ar.ar_arg_groups.gidset_size = gidset_size;
 233         ARG_SET_VALID(ar, ARG_GROUPSET);
 234 }
 235
 236 void
 237 audit_arg_login(struct kaudit_record *ar, char *login)
 238 {
 239
 240         strlcpy(ar->k_ar.ar_arg_login, login, MAXLOGNAME);
 241         ARG_SET_VALID(ar, ARG_LOGIN);
 242 }
 243
 244 void
 245 audit_arg_ctlname(struct kaudit_record *ar, int *name, int namelen)
 246 {
 247
 248         bcopy(name, &ar->k_ar.ar_arg_ctlname, namelen * sizeof(int));
 249         ar->k_ar.ar_arg_len = namelen;
 250         ARG_SET_VALID(ar, ARG_CTLNAME | ARG_LEN);
 251 }
 252
 253 void
 254 audit_arg_mask(struct kaudit_record *ar, int mask)
 255 {
 256
 257         ar->k_ar.ar_arg_mask = mask;
 258         ARG_SET_VALID(ar, ARG_MASK);
 259 }
 260
 261 void
 262 audit_arg_mode(struct kaudit_record *ar, mode_t mode)
 263 {
 264
 265         ar->k_ar.ar_arg_mode = mode;
 266         ARG_SET_VALID(ar, ARG_MODE);
 267 }
 268
 269 void
 270 audit_arg_value32(struct kaudit_record *ar, uint32_t value32)
 271 {
 272
 273         ar->k_ar.ar_arg_value32 = value32;
 274         ARG_SET_VALID(ar, ARG_VALUE32);
 275 }
 276
 277 void
 278 audit_arg_value64(struct kaudit_record *ar, uint64_t value64)
 279 {
 280
 281         ar->k_ar.ar_arg_value64 = value64;
 282         ARG_SET_VALID(ar, ARG_VALUE64);
 283 }
 284
 285 void
 286 audit_arg_owner(struct kaudit_record *ar, uid_t uid, gid_t gid)
 287 {
 288
 289         ar->k_ar.ar_arg_uid = uid;
 290         ar->k_ar.ar_arg_gid = gid;
 291         ARG_SET_VALID(ar, ARG_UID | ARG_GID);
 292 }
 293
 294 void
 295 audit_arg_pid(struct kaudit_record *ar, pid_t pid)
 296 {
 297
 298         ar->k_ar.ar_arg_pid = pid;
 299         ARG_SET_VALID(ar, ARG_PID);
 300 }
 301
 302 void
 303 audit_arg_process(struct kaudit_record *ar, proc_t p)
 304 {
 305         kauth_cred_t my_cred;
 306
 307         KASSERT(p != NULL, ("audit_arg_process: p == NULL"));
 308
 309         if ( p == NULL)
 310                 return;
 311
 312         my_cred = kauth_cred_proc_ref(p);
 313         ar->k_ar.ar_arg_auid = my_cred->cr_audit.as_aia_p->ai_auid;
 314         ar->k_ar.ar_arg_asid = my_cred->cr_audit.as_aia_p->ai_asid;
 315         bcopy(&my_cred->cr_audit.as_aia_p->ai_termid,
 316             &ar->k_ar.ar_arg_termid_addr, sizeof(au_tid_addr_t));
 317         ar->k_ar.ar_arg_euid = kauth_cred_getuid(my_cred);
 318         ar->k_ar.ar_arg_egid = kauth_cred_getgid(my_cred);
 319         ar->k_ar.ar_arg_ruid = kauth_cred_getruid(my_cred);
 320         ar->k_ar.ar_arg_rgid = kauth_cred_getrgid(my_cred);
 321         kauth_cred_unref(&my_cred);
 322         ar->k_ar.ar_arg_pid = p->p_pid;
 323         ARG_SET_VALID(ar, ARG_AUID | ARG_EUID | ARG_EGID | ARG_RUID |
 324             ARG_RGID | ARG_ASID | ARG_TERMID_ADDR | ARG_PID | ARG_PROCESS);
 325 }
 326
 327 void
 328 audit_arg_signum(struct kaudit_record *ar, u_int signum)
 329 {
 330
 331         ar->k_ar.ar_arg_signum = signum;
 332         ARG_SET_VALID(ar, ARG_SIGNUM);
 333 }
 334
 335 void
 336 audit_arg_socket(struct kaudit_record *ar, int sodomain, int sotype,
 337     int soprotocol)
 338 {
 339
 340         ar->k_ar.ar_arg_sockinfo.sai_domain = sodomain;
 341         ar->k_ar.ar_arg_sockinfo.sai_type = sotype;
 342         ar->k_ar.ar_arg_sockinfo.sai_protocol = soprotocol;
 343         ARG_SET_VALID(ar, ARG_SOCKINFO);
 344 }
 345
 346 /*
 347  * Note that the current working directory vp must be supplied at the audit
 348  * call site to permit per thread current working directories, and that it
 349  * must take a upath starting with '/' into account for chroot if the path
 350  * is absolute.  This results in the real (non-chroot) path being recorded
 351  * in the audit record.
 352  */
 353 void
 354 audit_arg_sockaddr(struct kaudit_record *ar, struct vnode *cwd_vp,
 355     struct sockaddr *sa)
 356 {
 357         char path[SOCK_MAXADDRLEN - offsetof(struct sockaddr_un, sun_path) + 1] = "";
 358         struct sockaddr_un *sun;
 359         ssize_t namelen;
 360
 361         KASSERT(sa != NULL, ("audit_arg_sockaddr: sa == NULL"));
 362
 363         if (cwd_vp == NULL || sa == NULL)
 364                 return;
 365
 366         if (sa->sa_len > sizeof(ar->k_ar.ar_arg_sockaddr))
 367                 bcopy(sa, &ar->k_ar.ar_arg_sockaddr, sizeof(ar->k_ar.ar_arg_sockaddr));
 368         else
 369                 bcopy(sa, &ar->k_ar.ar_arg_sockaddr, sa->sa_len);
 370
 371         switch (sa->sa_family) {
 372         case AF_INET:
 373                 ARG_SET_VALID(ar, ARG_SADDRINET);
 374                 break;
 375
 376         case AF_INET6:
 377                 ARG_SET_VALID(ar, ARG_SADDRINET6);
 378                 break;
 379
 380         case AF_UNIX:
 381                 sun = (struct sockaddr_un *)sa;
 382                 namelen = sun->sun_len - offsetof(struct sockaddr_un, sun_path);
 383                 if (namelen > 0 && (size_t)namelen < sizeof(path)) {
 384                         /*
 385                          * Make sure the path is NUL-terminated
 386                          */
 387                         bcopy(sun->sun_path, path, namelen);
 388                         path[namelen] = 0;
 389                         audit_arg_upath(ar, cwd_vp, path, ARG_UPATH1);
 390                 }
 391                 ARG_SET_VALID(ar, ARG_SADDRUNIX);
 392                 break;
 393         /* XXXAUDIT: default:? */
 394         }
 395 }
 396
 397 void
 398 audit_arg_auid(struct kaudit_record *ar, uid_t auid)
 399 {
 400
 401         ar->k_ar.ar_arg_auid = auid;
 402         ARG_SET_VALID(ar, ARG_AUID);
 403 }
 404
 405 void
 406 audit_arg_auditinfo(struct kaudit_record *ar, struct auditinfo *au_info)
 407 {
 408
 409         ar->k_ar.ar_arg_auid = au_info->ai_auid;
 410         ar->k_ar.ar_arg_asid = au_info->ai_asid;
 411         ar->k_ar.ar_arg_amask.am_success = au_info->ai_mask.am_success;
 412         ar->k_ar.ar_arg_amask.am_failure = au_info->ai_mask.am_failure;
 413         ar->k_ar.ar_arg_termid.port = au_info->ai_termid.port;
 414         ar->k_ar.ar_arg_termid.machine = au_info->ai_termid.machine;
 415         ARG_SET_VALID(ar, ARG_AUID | ARG_ASID | ARG_AMASK | ARG_TERMID);
 416 }
 417
 418 void
 419 audit_arg_auditinfo_addr(struct kaudit_record *ar,
 420     struct auditinfo_addr *au_info)
 421 {
 422
 423         ar->k_ar.ar_arg_auid = au_info->ai_auid;
 424         ar->k_ar.ar_arg_asid = au_info->ai_asid;
 425         ar->k_ar.ar_arg_amask.am_success = au_info->ai_mask.am_success;
 426         ar->k_ar.ar_arg_amask.am_failure = au_info->ai_mask.am_failure;
 427         ar->k_ar.ar_arg_termid_addr.at_type = au_info->ai_termid.at_type;
 428         ar->k_ar.ar_arg_termid_addr.at_port = au_info->ai_termid.at_port;
 429         ar->k_ar.ar_arg_termid_addr.at_addr[0] = au_info->ai_termid.at_addr[0];
 430         ar->k_ar.ar_arg_termid_addr.at_addr[1] = au_info->ai_termid.at_addr[1];
 431         ar->k_ar.ar_arg_termid_addr.at_addr[2] = au_info->ai_termid.at_addr[2];
 432         ar->k_ar.ar_arg_termid_addr.at_addr[3] = au_info->ai_termid.at_addr[3];
 433         ARG_SET_VALID(ar, ARG_AUID | ARG_ASID | ARG_AMASK | ARG_TERMID_ADDR);
 434 }
 435
 436 void
 437 audit_arg_text(struct kaudit_record *ar, char *text)
 438 {
 439
 440         KASSERT(text != NULL, ("audit_arg_text: text == NULL"));
 441
 442         /* Invalidate the text string */
 443         ar->k_ar.ar_valid_arg &= (ARG_ALL ^ ARG_TEXT);
 444         if (text == NULL)
 445                 return;
 446
 447         if (ar->k_ar.ar_arg_text == NULL)
 448                 ar->k_ar.ar_arg_text = malloc(MAXPATHLEN, M_AUDITTEXT,
 449                     M_WAITOK);
 450
 451         strncpy(ar->k_ar.ar_arg_text, text, MAXPATHLEN);
 452         ARG_SET_VALID(ar, ARG_TEXT);
 453 }
 454
 455 void
 456 audit_arg_opaque(struct kaudit_record *ar, void *data, size_t size)
 457 {
 458
 459         KASSERT(data != NULL, ("audit_arg_opaque: data == NULL"));
 460         KASSERT(size <= UINT16_MAX, ("audit_arg_opaque: size > UINT16_MAX"));
 461
 462         if (data == NULL || size > UINT16_MAX)
 463                 return;
 464
 465         if (ar->k_ar.ar_arg_opaque == NULL)
 466                 ar->k_ar.ar_arg_opaque = malloc(size, M_AUDITDATA, M_WAITOK);
 467         else
 468                 return;
 469
 470         memcpy(ar->k_ar.ar_arg_opaque, data, size);
 471         ar->k_ar.ar_arg_opq_size = (u_int16_t) size;
 472         ARG_SET_VALID(ar, ARG_OPAQUE);
 473 }
 474
 475 void
 476 audit_arg_data(struct kaudit_record *ar, void *data, size_t size, size_t number)
 477 {
 478         size_t sz;
 479
 480         KASSERT(data != NULL, ("audit_arg_data: data == NULL"));
 481         KASSERT(size >= AUR_BYTE_SIZE && size <= AUR_INT64_SIZE,
 482             ("audit_arg_data: size < AUR_BYTE_SIZE or size > AUR_INT64_SIZE"));
 483         KASSERT(number <= UINT8_MAX,
 484             ("audit_arg_data: number > UINT8_MAX"));
 485
 486         if (data == NULL || size < AUR_BYTE_SIZE || size > AUR_INT64_SIZE ||
 487             number > UINT8_MAX)
 488                 return;
 489
 490         sz = size * number;
 491
 492         if (ar->k_ar.ar_arg_data == NULL)
 493                 ar->k_ar.ar_arg_data = malloc(sz, M_AUDITDATA, M_WAITOK);
 494         else
 495                 return;
 496
 497         memcpy(ar->k_ar.ar_arg_data, data, sz);
 498
 499         switch(size) {
 500         case AUR_BYTE_SIZE:
 501                 ar->k_ar.ar_arg_data_type = AUR_BYTE;
 502                 break;
 503
 504         case AUR_SHORT_SIZE:
 505                 ar->k_ar.ar_arg_data_type = AUR_SHORT;
 506                 break;
 507
 508         case AUR_INT32_SIZE:
 509                 ar->k_ar.ar_arg_data_type = AUR_INT32;
 510                 break;
 511
 512         case AUR_INT64_SIZE:
 513                 ar->k_ar.ar_arg_data_type = AUR_INT64;
 514                 break;
 515
 516         default:
 517                 free(ar->k_ar.ar_arg_data, M_AUDITDATA);
 518                 ar->k_ar.ar_arg_data = NULL;
 519                 return;
 520         }
 521
 522         ar->k_ar.ar_arg_data_count = (u_char)number;
 523
 524         ARG_SET_VALID(ar, ARG_DATA);
 525 }
 526
 527 void
 528 audit_arg_cmd(struct kaudit_record *ar, int cmd)
 529 {
 530
 531         ar->k_ar.ar_arg_cmd = cmd;
 532         ARG_SET_VALID(ar, ARG_CMD);
 533 }
 534
 535 void
 536 audit_arg_svipc_cmd(struct kaudit_record *ar, int cmd)
 537 {
 538
 539         ar->k_ar.ar_arg_svipc_cmd = cmd;
 540         ARG_SET_VALID(ar, ARG_SVIPC_CMD);
 541 }
 542
 543 void
 544 audit_arg_svipc_perm(struct kaudit_record *ar, struct ipc_perm *perm)
 545 {
 546
 547         bcopy(perm, &ar->k_ar.ar_arg_svipc_perm,
 548             sizeof(ar->k_ar.ar_arg_svipc_perm));
 549         ARG_SET_VALID(ar, ARG_SVIPC_PERM);
 550 }
 551
 552 void
 553 audit_arg_svipc_id(struct kaudit_record *ar, int id)
 554 {
 555
 556         ar->k_ar.ar_arg_svipc_id = id;
 557         ARG_SET_VALID(ar, ARG_SVIPC_ID);
 558 }
 559
 560 void
 561 audit_arg_svipc_addr(struct kaudit_record *ar, user_addr_t addr)
 562 {
 563
 564         ar->k_ar.ar_arg_svipc_addr = addr;
 565         ARG_SET_VALID(ar, ARG_SVIPC_ADDR);
 566 }
 567
 568 void
 569 audit_arg_posix_ipc_perm(struct kaudit_record *ar, uid_t uid, gid_t gid,
 570     mode_t mode)
 571 {
 572
 573         ar->k_ar.ar_arg_pipc_perm.pipc_uid = uid;
 574         ar->k_ar.ar_arg_pipc_perm.pipc_gid = gid;
 575         ar->k_ar.ar_arg_pipc_perm.pipc_mode = mode;
 576         ARG_SET_VALID(ar, ARG_POSIX_IPC_PERM);
 577 }
 578
 579 void
 580 audit_arg_auditon(struct kaudit_record *ar, union auditon_udata *udata)
 581 {
 582
 583         bcopy((void *)udata, &ar->k_ar.ar_arg_auditon,
 584             sizeof(ar->k_ar.ar_arg_auditon));
 585         ARG_SET_VALID(ar, ARG_AUDITON);
 586 }
 587
 588 /*
 589  * Audit information about a file, either the file's vnode info, or its
 590  * socket address info.
 591  */
 592 void
 593 audit_arg_file(struct kaudit_record *ar, __unused proc_t p,
 594     struct fileproc *fp)
 595 {
 596         struct socket *so;
 597         struct inpcb *pcb;
 598         struct sockaddr_in *sin;
 599         struct sockaddr_in6 *sin6;
 600
 601         switch (FILEGLOB_DTYPE(fp->f_fglob)) {
 602         case DTYPE_VNODE:
 603         /* case DTYPE_FIFO: */
 604                 audit_arg_vnpath_withref(ar,
 605                     (struct vnode *)fp->f_fglob->fg_data, ARG_VNODE1);
 606                 break;
 607
 608         case DTYPE_SOCKET:
 609                 so = (struct socket *)fp->f_fglob->fg_data;
 610                 if (SOCK_CHECK_DOM(so, PF_INET)) {
 611                         if (so->so_pcb == NULL)
 612                                 break;
 613                         ar->k_ar.ar_arg_sockinfo.sai_type =
 614                             so->so_type;
 615                         ar->k_ar.ar_arg_sockinfo.sai_domain = SOCK_DOM(so);
 616                         ar->k_ar.ar_arg_sockinfo.sai_protocol = SOCK_PROTO(so);
 617                         pcb = (struct inpcb *)so->so_pcb;
 618                         sin = (struct sockaddr_in *)
 619                             &ar->k_ar.ar_arg_sockinfo.sai_faddr;
 620                         sin->sin_addr.s_addr = pcb->inp_faddr.s_addr;
 621                         sin->sin_port = pcb->inp_fport;
 622                         sin = (struct sockaddr_in *)
 623                             &ar->k_ar.ar_arg_sockinfo.sai_laddr;
 624                         sin->sin_addr.s_addr = pcb->inp_laddr.s_addr;
 625                         sin->sin_port = pcb->inp_lport;
 626                         ARG_SET_VALID(ar, ARG_SOCKINFO);
 627                 }
 628                 if (SOCK_CHECK_DOM(so, PF_INET6)) {
 629                         if (so->so_pcb == NULL)
 630                                 break;
 631                         ar->k_ar.ar_arg_sockinfo.sai_type =
 632                             so->so_type;
 633                         ar->k_ar.ar_arg_sockinfo.sai_domain = SOCK_DOM(so);
 634                         ar->k_ar.ar_arg_sockinfo.sai_protocol = SOCK_PROTO(so);
 635                         pcb = (struct inpcb *)so->so_pcb;
 636                         sin6 = (struct sockaddr_in6 *)
 637                             &ar->k_ar.ar_arg_sockinfo.sai_faddr;
 638                         sin6->sin6_addr = pcb->in6p_faddr;
 639                         sin6->sin6_port = pcb->in6p_fport;
 640                         sin6 = (struct sockaddr_in6 *)
 641                             &ar->k_ar.ar_arg_sockinfo.sai_laddr;
 642                         sin6->sin6_addr = pcb->in6p_laddr;
 643                         sin6->sin6_port = pcb->in6p_lport;
 644                         ARG_SET_VALID(ar, ARG_SOCKINFO);
 645                 }
 646                 break;
 647
 648         default:
 649                 /* XXXAUDIT: else? */
 650                 break;
 651         }
 652 }
 653
 654 /*
 655  * Store a path as given by the user process for auditing into the audit
 656  * record stored on the user thread.  This function will allocate the memory
 657  * to store the path info if not already available.  This memory will be
 658  * freed when the audit record is freed.
 659  *
 660  * Note that the current working directory vp must be supplied at the audit call
 661  * site to permit per thread current working directories, and that it must take
 662  * a upath starting with '/' into account for chroot if the path is absolute.
 663  * This results in the real (non-chroot) path being recorded in the audit
 664  * record.
 665  *
 666  * XXXAUDIT: Possibly assert that the memory isn't already allocated?
 667  */
 668 void
 669 audit_arg_upath(struct kaudit_record *ar, struct vnode *cwd_vp, char *upath, u_int64_t flag)
 670 {
 671         char **pathp;
 672
 673         KASSERT(upath != NULL, ("audit_arg_upath: upath == NULL"));
 674         KASSERT((flag == ARG_UPATH1) || (flag == ARG_UPATH2),
 675             ("audit_arg_upath: flag %llu", (unsigned long long)flag));
 676         KASSERT((flag != ARG_UPATH1) || (flag != ARG_UPATH2),
 677             ("audit_arg_upath: flag %llu", (unsigned long long)flag));
 678
 679         if (flag == ARG_UPATH1)
 680                 pathp = &ar->k_ar.ar_arg_upath1;
 681         else
 682                 pathp = &ar->k_ar.ar_arg_upath2;
 683
 684         if (*pathp == NULL)
 685                 *pathp = malloc(MAXPATHLEN, M_AUDITPATH, M_WAITOK);
 686         else
 687                 return;
 688
 689         if (audit_canon_path(cwd_vp, upath, *pathp) == 0)
 690                 ARG_SET_VALID(ar, flag);
 691         else {
 692                 free(*pathp, M_AUDITPATH);
 693                 *pathp = NULL;
 694         }
 695 }
 696
 697 /*
 698  * Function to save the path and vnode attr information into the audit
 699  * record.
 700  *
 701  * It is assumed that the caller will hold any vnode locks necessary to
 702  * perform a VNOP_GETATTR() on the passed vnode.
 703  *
 704  * XXX: The attr code is very similar to vfs_vnops.c:vn_stat(), but always
 705  * provides access to the generation number as we need that to construct the
 706  * BSM file ID.
 707  *
 708  * XXX: We should accept the process argument from the caller, since it's
 709  * very likely they already have a reference.
 710  *
 711  * XXX: Error handling in this function is poor.
 712  *
 713  * XXXAUDIT: Possibly KASSERT the path pointer is NULL?
 714  */
 715 void
 716 audit_arg_vnpath(struct kaudit_record *ar, struct vnode *vp, u_int64_t flags)
 717 {
 718         struct vnode_attr va;
 719         int error;
 720         int len;
 721         char **pathp;
 722         struct vnode_au_info *vnp;
 723         proc_t p;
 724 #if CONFIG_MACF
 725         char **vnode_mac_labelp;
 726         struct mac mac;
 727 #endif
 728
 729         KASSERT(vp != NULL, ("audit_arg_vnpath: vp == NULL"));
 730         KASSERT((flags == ARG_VNODE1) || (flags == ARG_VNODE2),
 731             ("audit_arg_vnpath: flags != ARG_VNODE[1,2]"));
 732
 733         p = current_proc();
 734
 735         /*
 736          * XXXAUDIT: The below clears, and then resets the flags for valid
 737          * arguments.  Ideally, either the new vnode is used, or the old one
 738          * would be.
 739          */
 740         if (flags & ARG_VNODE1) {
 741                 ar->k_ar.ar_valid_arg &= (ARG_ALL ^ ARG_KPATH1);
 742                 ar->k_ar.ar_valid_arg &= (ARG_ALL ^ ARG_VNODE1);
 743                 pathp = &ar->k_ar.ar_arg_kpath1;
 744                 vnp = &ar->k_ar.ar_arg_vnode1;
 745 #if CONFIG_MACF
 746                 vnode_mac_labelp = &ar->k_ar.ar_vnode1_mac_labels;
 747 #endif
 748         } else {
 749                 ar->k_ar.ar_valid_arg &= (ARG_ALL ^ ARG_KPATH2);
 750                 ar->k_ar.ar_valid_arg &= (ARG_ALL ^ ARG_VNODE2);
 751                 pathp = &ar->k_ar.ar_arg_kpath2;
 752                 vnp = &ar->k_ar.ar_arg_vnode2;
 753 #if CONFIG_MACF
 754                 vnode_mac_labelp = &ar->k_ar.ar_vnode2_mac_labels;
 755 #endif
 756         }
 757
 758         if (*pathp == NULL)
 759                 *pathp = malloc(MAXPATHLEN, M_AUDITPATH, M_WAITOK);
 760         else
 761                 return;
 762
 763         /*
 764          * If vn_getpath() succeeds, place it in a string buffer
 765          * attached to the audit record, and set a flag indicating
 766          * it is present.
 767          */
 768         len = MAXPATHLEN;
 769         if (vn_getpath(vp, *pathp, &len) == 0) {
 770                 if (flags & ARG_VNODE1)
 771                         ARG_SET_VALID(ar, ARG_KPATH1);
 772                 else
 773                         ARG_SET_VALID(ar, ARG_KPATH2);
 774         } else {
 775                 free(*pathp, M_AUDITPATH);
 776                 *pathp = NULL;
 777         }
 778
 779         VATTR_INIT(&va);
 780         VATTR_WANTED(&va, va_mode);
 781         VATTR_WANTED(&va, va_uid);
 782         VATTR_WANTED(&va, va_gid);
 783         VATTR_WANTED(&va, va_rdev);
 784         VATTR_WANTED(&va, va_fsid);
 785         VATTR_WANTED(&va, va_fileid);
 786         VATTR_WANTED(&va, va_gen);
 787         error = vnode_getattr(vp, &va, vfs_context_current());
 788         if (error) {
 789                 /* XXX: How to handle this case? */
 790                 return;
 791         }
 792
 793 #if CONFIG_MACF
 794         if (*vnode_mac_labelp == NULL && (vp->v_lflag & VL_LABELED) == VL_LABELED) {
 795                 *vnode_mac_labelp = (char *)zalloc(audit_mac_label_zone);
 796                 if (*vnode_mac_labelp != NULL) {
 797                         mac.m_buflen = MAC_AUDIT_LABEL_LEN;
 798                         mac.m_string = *vnode_mac_labelp;
 799                         mac_vnode_label_externalize_audit(vp, &mac);
 800                 }
 801         }
 802 #endif
 803
 804         /*
 805          * XXX do we want to fall back here when these aren't supported?
 806          */
 807         vnp->vn_mode = va.va_mode;
 808         vnp->vn_uid = va.va_uid;
 809         vnp->vn_gid = va.va_gid;
 810         vnp->vn_dev = va.va_rdev;
 811         vnp->vn_fsid = va.va_fsid;
 812         vnp->vn_fileid = (u_int32_t)va.va_fileid;
 813         vnp->vn_gen = va.va_gen;
 814         if (flags & ARG_VNODE1)
 815                 ARG_SET_VALID(ar, ARG_VNODE1);
 816         else
 817                 ARG_SET_VALID(ar, ARG_VNODE2);
 818 }
 819
 820 void
 821 audit_arg_vnpath_withref(struct kaudit_record *ar, struct vnode *vp, u_int64_t flags)
 822 {
 823         if (vp == NULL || vnode_getwithref(vp))
 824                 return;
 825         audit_arg_vnpath(ar, vp, flags);
 826         (void)vnode_put(vp);
 827 }
 828
 829 void
 830 audit_arg_mach_port1(struct kaudit_record *ar, mach_port_name_t port)
 831 {
 832
 833         ar->k_ar.ar_arg_mach_port1 = port;
 834         ARG_SET_VALID(ar, ARG_MACHPORT1);
 835 }
 836
 837 void
 838 audit_arg_mach_port2(struct kaudit_record *ar, mach_port_name_t port)
 839 {
 840
 841         ar->k_ar.ar_arg_mach_port2 = port;
 842         ARG_SET_VALID(ar, ARG_MACHPORT2);
 843 }
 844
 845
 846 /*
 847  * Audit the argument strings passed to exec.
 848  */
 849 void
 850 audit_arg_argv(struct kaudit_record *ar, char *argv, int argc, int length)
 851 {
 852
 853         if (audit_argv == 0 || argc == 0)
 854                 return;
 855
 856         if (ar->k_ar.ar_arg_argv == NULL)
 857                 ar->k_ar.ar_arg_argv = malloc(length, M_AUDITTEXT, M_WAITOK);
 858         bcopy(argv, ar->k_ar.ar_arg_argv, length);
 859         ar->k_ar.ar_arg_argc = argc;
 860         ARG_SET_VALID(ar, ARG_ARGV);
 861 }
 862
 863 /*
 864  * Audit the environment strings passed to exec.
 865  */
 866 void
 867 audit_arg_envv(struct kaudit_record *ar, char *envv, int envc, int length)
 868 {
 869
 870         if (audit_arge == 0 || envc == 0)
 871                 return;
 872
 873         if (ar->k_ar.ar_arg_envv == NULL)
 874                 ar->k_ar.ar_arg_envv = malloc(length, M_AUDITTEXT, M_WAITOK);
 875         bcopy(envv, ar->k_ar.ar_arg_envv, length);
 876         ar->k_ar.ar_arg_envc = envc;
 877         ARG_SET_VALID(ar, ARG_ENVV);
 878 }
 879
 880 /*
 881  * The close() system call uses it's own audit call to capture the path/vnode
 882  * information because those pieces are not easily obtained within the system
 883  * call itself.
 884  */
 885 void
 886 audit_sysclose(struct kaudit_record *ar, proc_t p, int fd)
 887 {
 888         struct fileproc *fp;
 889         struct vnode *vp;
 890
 891         KASSERT(p != NULL, ("audit_sysclose: p == NULL"));
 892
 893         audit_arg_fd(ar, fd);
 894
 895         if (fp_getfvp(p, fd, &fp, &vp) != 0)
 896                 return;
 897
 898         audit_arg_vnpath_withref(ar, (struct vnode *)fp->f_fglob->fg_data,
 899             ARG_VNODE1);
 900         fp_drop(p, fd, fp, 0);
 901 }
 902
 903 #endif /* CONFIG_AUDIT */