sys/security/audit/audit_private.h

   1 /*-
   2  * Copyright (c) 1999-2009 Apple Inc.
   3  * Copyright (c) 2016-2017 Robert N. M. Watson
   4  * All rights reserved.
   5  *
   6  * Portions of this software were developed by BAE Systems, the University of
   7  * Cambridge Computer Laboratory, and Memorial University under DARPA/AFRL
   8  * contract FA8650-15-C-7558 ("CADETS"), as part of the DARPA Transparent
   9  * Computing (TC) research program.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1.  Redistributions of source code must retain the above copyright
  15  *     notice, this list of conditions and the following disclaimer.
  16  * 2.  Redistributions in binary form must reproduce the above copyright
  17  *     notice, this list of conditions and the following disclaimer in the
  18  *     documentation and/or other materials provided with the distribution.
  19  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  20  *     its contributors may be used to endorse or promote products derived
  21  *     from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
  27  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  32  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * $FreeBSD$
  36  */
  37
  38 /*
  39  * This include file contains function prototypes and type definitions used
  40  * within the audit implementation.
  41  */
  42
  43 #ifndef _SECURITY_AUDIT_PRIVATE_H_
  44 #define _SECURITY_AUDIT_PRIVATE_H_
  45
  46 #ifndef _KERNEL
  47 #error "no user-serviceable parts inside"
  48 #endif
  49
  50 #include <sys/caprights.h>
  51 #include <sys/ipc.h>
  52 #include <sys/socket.h>
  53 #include <sys/ucred.h>
  54
  55 #ifdef MALLOC_DECLARE
  56 MALLOC_DECLARE(M_AUDITBSM);
  57 MALLOC_DECLARE(M_AUDITDATA);
  58 MALLOC_DECLARE(M_AUDITPATH);
  59 MALLOC_DECLARE(M_AUDITTEXT);
  60 MALLOC_DECLARE(M_AUDITGIDSET);
  61 #endif
  62
  63 /*
  64  * Audit control variables that are usually set/read via system calls and
  65  * used to control various aspects of auditing.
  66  */
  67 extern struct au_qctrl          audit_qctrl;
  68 extern struct audit_fstat       audit_fstat;
  69 extern struct au_mask           audit_nae_mask;
  70 extern int                      audit_panic_on_write_fail;
  71 extern int                      audit_fail_stop;
  72 extern int                      audit_argv;
  73 extern int                      audit_arge;
  74
  75 /*
  76  * Success/failure conditions for the conversion of a kernel audit record to
  77  * BSM format.
  78  */
  79 #define BSM_SUCCESS     0
  80 #define BSM_FAILURE     1
  81 #define BSM_NOAUDIT     2
  82
  83 /*
  84  * Defines for the kernel audit record k_ar_commit field.  Flags are set to
  85  * indicate what sort of record it is, and which preselection mechanism
  86  * selected it.
  87  */
  88 #define AR_COMMIT_KERNEL        0x00000001U
  89 #define AR_COMMIT_USER          0x00000010U
  90
  91 #define AR_PRESELECT_TRAIL      0x00001000U
  92 #define AR_PRESELECT_PIPE       0x00002000U
  93
  94 #define AR_PRESELECT_USER_TRAIL 0x00004000U
  95 #define AR_PRESELECT_USER_PIPE  0x00008000U
  96
  97 #define AR_PRESELECT_DTRACE     0x00010000U
  98
  99 /*
 100  * Audit data is generated as a stream of struct audit_record structures,
 101  * linked by struct kaudit_record, and contain storage for possible audit so
 102  * that it will not need to be allocated during the processing of a system
 103  * call, both improving efficiency and avoiding sleeping at untimely moments.
 104  * This structure is converted to BSM format before being written to disk.
 105  */
 106 struct vnode_au_info {
 107         mode_t  vn_mode;
 108         uid_t   vn_uid;
 109         gid_t   vn_gid;
 110         u_int32_t vn_dev;               /* XXX dev_t compatibility */
 111         long    vn_fsid;                /* XXX uint64_t compatibility */
 112         long    vn_fileid;              /* XXX ino_t compatibility */
 113         long    vn_gen;
 114 };
 115
 116 struct groupset {
 117         gid_t   *gidset;
 118         u_int    gidset_size;
 119 };
 120
 121 struct socket_au_info {
 122         int             so_domain;
 123         int             so_type;
 124         int             so_protocol;
 125         in_addr_t       so_raddr;       /* Remote address if INET socket. */
 126         in_addr_t       so_laddr;       /* Local address if INET socket. */
 127         u_short         so_rport;       /* Remote port. */
 128         u_short         so_lport;       /* Local port. */
 129 };
 130
 131 /*
 132  * The following is used for A_OLDSETQCTRL and AU_OLDGETQCTRL and a 64-bit
 133  * userland.
 134  */
 135 struct au_qctrl64 {
 136         u_int64_t       aq64_hiwater;
 137         u_int64_t       aq64_lowater;
 138         u_int64_t       aq64_bufsz;
 139         u_int64_t       aq64_delay;
 140         u_int64_t       aq64_minfree;
 141 };
 142 typedef struct au_qctrl64       au_qctrl64_t;
 143
 144 union auditon_udata {
 145         char                    *au_path;
 146         int                     au_cond;
 147         int                     au_flags;
 148         int                     au_policy;
 149         int                     au_trigger;
 150         int64_t                 au_cond64;
 151         int64_t                 au_policy64;
 152         au_evclass_map_t        au_evclass;
 153         au_mask_t               au_mask;
 154         auditinfo_t             au_auinfo;
 155         auditpinfo_t            au_aupinfo;
 156         auditpinfo_addr_t       au_aupinfo_addr;
 157         au_qctrl_t              au_qctrl;
 158         au_qctrl64_t            au_qctrl64;
 159         au_stat_t               au_stat;
 160         au_fstat_t              au_fstat;
 161         auditinfo_addr_t        au_kau_info;
 162         au_evname_map_t         au_evname;
 163 };
 164
 165 struct posix_ipc_perm {
 166         uid_t   pipc_uid;
 167         gid_t   pipc_gid;
 168         mode_t  pipc_mode;
 169 };
 170
 171 struct audit_record {
 172         /* Audit record header. */
 173         u_int32_t               ar_magic;
 174         int                     ar_event;
 175         int                     ar_retval; /* value returned to the process */
 176         int                     ar_errno;  /* return status of system call */
 177         struct timespec         ar_starttime;
 178         struct timespec         ar_endtime;
 179         u_int64_t               ar_valid_arg;  /* Bitmask of valid arguments */
 180
 181         /* Audit subject information. */
 182         struct xucred           ar_subj_cred;
 183         uid_t                   ar_subj_ruid;
 184         gid_t                   ar_subj_rgid;
 185         gid_t                   ar_subj_egid;
 186         uid_t                   ar_subj_auid; /* Audit user ID */
 187         pid_t                   ar_subj_asid; /* Audit session ID */
 188         pid_t                   ar_subj_pid;
 189         struct au_tid           ar_subj_term;
 190         struct au_tid_addr      ar_subj_term_addr;
 191         struct au_mask          ar_subj_amask;
 192
 193         /* Operation arguments. */
 194         uid_t                   ar_arg_euid;
 195         uid_t                   ar_arg_ruid;
 196         uid_t                   ar_arg_suid;
 197         gid_t                   ar_arg_egid;
 198         gid_t                   ar_arg_rgid;
 199         gid_t                   ar_arg_sgid;
 200         pid_t                   ar_arg_pid;
 201         pid_t                   ar_arg_asid;
 202         struct au_tid           ar_arg_termid;
 203         struct au_tid_addr      ar_arg_termid_addr;
 204         uid_t                   ar_arg_uid;
 205         uid_t                   ar_arg_auid;
 206         gid_t                   ar_arg_gid;
 207         struct groupset         ar_arg_groups;
 208         int                     ar_arg_fd;
 209         int                     ar_arg_atfd1;
 210         int                     ar_arg_atfd2;
 211         int                     ar_arg_fflags;
 212         mode_t                  ar_arg_mode;
 213         int                     ar_arg_dev;     /* XXX dev_t compatibility */
 214         long                    ar_arg_value;
 215         void                    *ar_arg_addr;
 216         int                     ar_arg_len;
 217         int                     ar_arg_mask;
 218         u_int                   ar_arg_signum;
 219         char                    ar_arg_login[MAXLOGNAME];
 220         int                     ar_arg_ctlname[CTL_MAXNAME];
 221         struct socket_au_info   ar_arg_sockinfo;
 222         char                    *ar_arg_upath1;
 223         char                    *ar_arg_upath2;
 224         char                    *ar_arg_text;
 225         struct au_mask          ar_arg_amask;
 226         struct vnode_au_info    ar_arg_vnode1;
 227         struct vnode_au_info    ar_arg_vnode2;
 228         int                     ar_arg_cmd;
 229         int                     ar_arg_svipc_which;
 230         int                     ar_arg_svipc_cmd;
 231         struct ipc_perm         ar_arg_svipc_perm;
 232         int                     ar_arg_svipc_id;
 233         void                    *ar_arg_svipc_addr;
 234         struct posix_ipc_perm   ar_arg_pipc_perm;
 235         union auditon_udata     ar_arg_auditon;
 236         char                    *ar_arg_argv;
 237         int                     ar_arg_argc;
 238         char                    *ar_arg_envv;
 239         int                     ar_arg_envc;
 240         int                     ar_arg_exitstatus;
 241         int                     ar_arg_exitretval;
 242         struct sockaddr_storage ar_arg_sockaddr;
 243         cap_rights_t            ar_arg_rights;
 244         uint32_t                ar_arg_fcntl_rights;
 245         char                    ar_jailname[MAXHOSTNAMELEN];
 246 };
 247
 248 /*
 249  * Arguments in the audit record are initially not defined; flags are set to
 250  * indicate if they are present so they can be included in the audit log
 251  * stream only if defined.
 252  */
 253 #define ARG_EUID                0x0000000000000001ULL
 254 #define ARG_RUID                0x0000000000000002ULL
 255 #define ARG_SUID                0x0000000000000004ULL
 256 #define ARG_EGID                0x0000000000000008ULL
 257 #define ARG_RGID                0x0000000000000010ULL
 258 #define ARG_SGID                0x0000000000000020ULL
 259 #define ARG_PID                 0x0000000000000040ULL
 260 #define ARG_UID                 0x0000000000000080ULL
 261 #define ARG_AUID                0x0000000000000100ULL
 262 #define ARG_GID                 0x0000000000000200ULL
 263 #define ARG_FD                  0x0000000000000400ULL
 264 #define ARG_POSIX_IPC_PERM      0x0000000000000800ULL
 265 #define ARG_FFLAGS              0x0000000000001000ULL
 266 #define ARG_MODE                0x0000000000002000ULL
 267 #define ARG_DEV                 0x0000000000004000ULL
 268 #define ARG_ADDR                0x0000000000008000ULL
 269 #define ARG_LEN                 0x0000000000010000ULL
 270 #define ARG_MASK                0x0000000000020000ULL
 271 #define ARG_SIGNUM              0x0000000000040000ULL
 272 #define ARG_LOGIN               0x0000000000080000ULL
 273 #define ARG_SADDRINET           0x0000000000100000ULL
 274 #define ARG_SADDRINET6          0x0000000000200000ULL
 275 #define ARG_SADDRUNIX           0x0000000000400000ULL
 276 #define ARG_TERMID_ADDR         0x0000000000400000ULL
 277 #define ARG_UNUSED2             0x0000000001000000ULL
 278 #define ARG_UPATH1              0x0000000002000000ULL
 279 #define ARG_UPATH2              0x0000000004000000ULL
 280 #define ARG_TEXT                0x0000000008000000ULL
 281 #define ARG_VNODE1              0x0000000010000000ULL
 282 #define ARG_VNODE2              0x0000000020000000ULL
 283 #define ARG_SVIPC_CMD           0x0000000040000000ULL
 284 #define ARG_SVIPC_PERM          0x0000000080000000ULL
 285 #define ARG_SVIPC_ID            0x0000000100000000ULL
 286 #define ARG_SVIPC_ADDR          0x0000000200000000ULL
 287 #define ARG_GROUPSET            0x0000000400000000ULL
 288 #define ARG_CMD                 0x0000000800000000ULL
 289 #define ARG_SOCKINFO            0x0000001000000000ULL
 290 #define ARG_ASID                0x0000002000000000ULL
 291 #define ARG_TERMID              0x0000004000000000ULL
 292 #define ARG_AUDITON             0x0000008000000000ULL
 293 #define ARG_VALUE               0x0000010000000000ULL
 294 #define ARG_AMASK               0x0000020000000000ULL
 295 #define ARG_CTLNAME             0x0000040000000000ULL
 296 #define ARG_PROCESS             0x0000080000000000ULL
 297 #define ARG_MACHPORT1           0x0000100000000000ULL
 298 #define ARG_MACHPORT2           0x0000200000000000ULL
 299 #define ARG_EXIT                0x0000400000000000ULL
 300 #define ARG_IOVECSTR            0x0000800000000000ULL
 301 #define ARG_ARGV                0x0001000000000000ULL
 302 #define ARG_ENVV                0x0002000000000000ULL
 303 #define ARG_ATFD1               0x0004000000000000ULL
 304 #define ARG_ATFD2               0x0008000000000000ULL
 305 #define ARG_RIGHTS              0x0010000000000000ULL
 306 #define ARG_FCNTL_RIGHTS        0x0020000000000000ULL
 307 #define ARG_SVIPC_WHICH         0x0200000000000000ULL
 308 #define ARG_NONE                0x0000000000000000ULL
 309 #define ARG_ALL                 0xFFFFFFFFFFFFFFFFULL
 310
 311 #define ARG_IS_VALID(kar, arg)  ((kar)->k_ar.ar_valid_arg & (arg))
 312 #define ARG_SET_VALID(kar, arg) do {                                    \
 313         (kar)->k_ar.ar_valid_arg |= (arg);                              \
 314 } while (0)
 315 #define ARG_CLEAR_VALID(kar, arg) do {                                  \
 316         (kar)->k_ar.ar_valid_arg &= ~(arg);                             \
 317 } while (0)
 318
 319 /*
 320  * In-kernel version of audit record; the basic record plus queue meta-data.
 321  * This record can also have a pointer set to some opaque data that will be
 322  * passed through to the audit writing mechanism.
 323  */
 324 struct kaudit_record {
 325         struct audit_record              k_ar;
 326         u_int32_t                        k_ar_commit;
 327         void                            *k_udata;       /* User data. */
 328         u_int                            k_ulen;        /* User data length. */
 329         struct uthread                  *k_uthread;     /* Audited thread. */
 330         void                            *k_dtaudit_state;
 331         TAILQ_ENTRY(kaudit_record)       k_q;
 332 };
 333 TAILQ_HEAD(kaudit_queue, kaudit_record);
 334
 335 /*
 336  * Functions to manage the allocation, release, and commit of kernel audit
 337  * records.
 338  */
 339 void                     audit_abort(struct kaudit_record *ar);
 340 void                     audit_commit(struct kaudit_record *ar, int error,
 341                             int retval);
 342 struct kaudit_record    *audit_new(int event, struct thread *td);
 343
 344 /*
 345  * Functions relating to the conversion of internal kernel audit records to
 346  * the BSM file format.
 347  */
 348 struct au_record;
 349 int      kaudit_to_bsm(struct kaudit_record *kar, struct au_record **pau);
 350 int      bsm_rec_verify(void *rec);
 351
 352 /*
 353  * Kernel versions of the libbsm audit record functions.
 354  */
 355 void     kau_free(struct au_record *rec);
 356 void     kau_init(void);
 357
 358 /*
 359  * Return values for pre-selection and post-selection decisions.
 360  */
 361 #define AU_PRS_SUCCESS  1
 362 #define AU_PRS_FAILURE  2
 363 #define AU_PRS_BOTH     (AU_PRS_SUCCESS|AU_PRS_FAILURE)
 364
 365 /*
 366  * Data structures relating to the kernel audit queue.  Ideally, these might
 367  * be abstracted so that only accessor methods are exposed.
 368  */
 369 extern struct mtx               audit_mtx;
 370 extern struct cv                audit_watermark_cv;
 371 extern struct cv                audit_worker_cv;
 372 extern struct kaudit_queue      audit_q;
 373 extern int                      audit_q_len;
 374 extern int                      audit_pre_q_len;
 375 extern int                      audit_in_failure;
 376
 377 /*
 378  * Flags to use on audit files when opening and closing.
 379  */
 380 #define AUDIT_OPEN_FLAGS        (FWRITE | O_APPEND)
 381 #define AUDIT_CLOSE_FLAGS       (FWRITE | O_APPEND)
 382
 383 /*
 384  * Audit event-to-name mapping structure, maintained in audit_bsm_klib.c.  It
 385  * appears in this header so that the DTrace audit provider can dereference
 386  * instances passed back in the au_evname_foreach() callbacks.  Safe access to
 387  * its fields requires holding ene_lock (after it is visible in the global
 388  * table).
 389  *
 390  * Locking:
 391  * (c) - Constant after inserted in the global table
 392  * (l) - Protected by ene_lock
 393  * (m) - Protected by evnamemap_lock (audit_bsm_klib.c)
 394  * (M) - Writes protected by evnamemap_lock; reads unprotected.
 395  */
 396 struct evname_elem {
 397         au_event_t              ene_event;                      /* (c) */
 398         char                    ene_name[EVNAMEMAP_NAME_SIZE];  /* (l) */
 399         LIST_ENTRY(evname_elem) ene_entry;                      /* (m) */
 400         struct mtx              ene_lock;
 401
 402         /* DTrace probe IDs; 0 if not yet registered. */
 403         uint32_t                ene_commit_probe_id;            /* (M) */
 404         uint32_t                ene_bsm_probe_id;               /* (M) */
 405
 406         /* Flags indicating if the probes enabled or not. */
 407         int                     ene_commit_probe_enabled;       /* (M) */
 408         int                     ene_bsm_probe_enabled;          /* (M) */
 409 };
 410
 411 #define EVNAME_LOCK(ene)        mtx_lock(&(ene)->ene_lock)
 412 #define EVNAME_UNLOCK(ene)      mtx_unlock(&(ene)->ene_lock)
 413
 414 /*
 415  * Callback function typedef for the same.
 416  */
 417 typedef void    (*au_evnamemap_callback_t)(struct evname_elem *ene);
 418
 419 /*
 420  * DTrace audit provider (dtaudit) hooks -- to be set non-NULL when the audit
 421  * provider is loaded and ready to be called into.
 422  */
 423 extern void     *(*dtaudit_hook_preselect)(au_id_t auid, au_event_t event,
 424                     au_class_t class);
 425 extern int      (*dtaudit_hook_commit)(struct kaudit_record *kar,
 426                     au_id_t auid, au_event_t event, au_class_t class,
 427                     int sorf);
 428 extern void     (*dtaudit_hook_bsm)(struct kaudit_record *kar, au_id_t auid,
 429                     au_event_t event, au_class_t class, int sorf,
 430                     void *bsm_data, size_t bsm_len);
 431
 432 #include <sys/fcntl.h>
 433 #include <sys/kernel.h>
 434 #include <sys/malloc.h>
 435
 436 /*
 437  * Some of the BSM tokenizer functions take different parameters in the
 438  * kernel implementations in order to save the copying of large kernel data
 439  * structures.  The prototypes of these functions are declared here.
 440  */
 441 token_t         *kau_to_socket(struct socket_au_info *soi);
 442
 443 /*
 444  * audit_klib prototypes
 445  */
 446 int              au_preselect(au_event_t event, au_class_t class,
 447                     au_mask_t *mask_p, int sorf);
 448 void             au_evclassmap_init(void);
 449 void             au_evclassmap_insert(au_event_t event, au_class_t class);
 450 au_class_t       au_event_class(au_event_t event);
 451 void             au_evnamemap_init(void);
 452 void             au_evnamemap_insert(au_event_t event, const char *name);
 453 void             au_evnamemap_foreach(au_evnamemap_callback_t callback);
 454 struct evname_elem      *au_evnamemap_lookup(au_event_t event);
 455 int              au_event_name(au_event_t event, char *name);
 456 au_event_t       audit_ctlname_to_sysctlevent(int name[], uint64_t valid_arg);
 457 au_event_t       audit_flags_and_error_to_openevent(int oflags, int error);
 458 au_event_t       audit_flags_and_error_to_openatevent(int oflags, int error);
 459 au_event_t       audit_msgctl_to_event(int cmd);
 460 au_event_t       audit_msgsys_to_event(int which);
 461 au_event_t       audit_semctl_to_event(int cmd);
 462 au_event_t       audit_semsys_to_event(int which);
 463 au_event_t       audit_shmsys_to_event(int which);
 464 void             audit_canon_path(struct thread *td, int dirfd, char *path,
 465                     char *cpath);
 466 au_event_t       auditon_command_event(int cmd);
 467
 468 /*
 469  * Audit trigger events notify user space of kernel audit conditions
 470  * asynchronously.
 471  */
 472 void             audit_trigger_init(void);
 473 int              audit_send_trigger(unsigned int trigger);
 474
 475 /*
 476  * Accessor functions to manage global audit state.
 477  */
 478 void     audit_set_kinfo(struct auditinfo_addr *);
 479 void     audit_get_kinfo(struct auditinfo_addr *);
 480
 481 /*
 482  * General audit related functions.
 483  */
 484 struct kaudit_record    *currecord(void);
 485 void                     audit_free(struct kaudit_record *ar);
 486 void                     audit_shutdown(void *arg, int howto);
 487 void                     audit_rotate_vnode(struct ucred *cred,
 488                             struct vnode *vp);
 489 void                     audit_worker_init(void);
 490
 491 /*
 492  * Audit pipe functions.
 493  */
 494 int      audit_pipe_preselect(au_id_t auid, au_event_t event,
 495             au_class_t class, int sorf, int trail_select);
 496 void     audit_pipe_submit(au_id_t auid, au_event_t event, au_class_t class,
 497             int sorf, int trail_select, void *record, u_int record_len);
 498 void     audit_pipe_submit_user(void *record, u_int record_len);
 499
 500 #endif /* ! _SECURITY_AUDIT_PRIVATE_H_ */