sys/security/audit/audit.h

   1 /*-
   2  * Copyright (c) 1999-2005 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  * $FreeBSD$
  30  */
  31
  32 /*
  33  * This header includes function prototypes and type definitions that are
  34  * necessary for the kernel as a whole to interact with the audit subsystem.
  35  */
  36
  37 #ifndef _SECURITY_AUDIT_KERNEL_H_
  38 #define _SECURITY_AUDIT_KERNEL_H_
  39
  40 #ifndef _KERNEL
  41 #error "no user-serviceable parts inside"
  42 #endif
  43
  44 #include <bsm/audit.h>
  45
  46 #include <sys/file.h>
  47 #include <sys/sysctl.h>
  48
  49 /*
  50  * Audit subsystem condition flags.  The audit_enabled flag is set and
  51  * removed automatically as a result of configuring log files, and can be
  52  * observed but should not be directly manipulated.  The audit suspension
  53  * flag permits audit to be temporarily disabled without reconfiguring the
  54  * audit target.
  55  */
  56 extern int      audit_enabled;
  57 extern int      audit_suspended;
  58
  59 /*
  60  * Define the masks for the audited arguments.
  61  *
  62  * XXXRW: These need to remain in audit.h for now because our vnode and name
  63  * lookup audit calls rely on passing in flags to indicate which name or
  64  * vnode is being logged.  These should move to audit_private.h when that is
  65  * fixed.
  66  */
  67 #define ARG_EUID                0x0000000000000001ULL
  68 #define ARG_RUID                0x0000000000000002ULL
  69 #define ARG_SUID                0x0000000000000004ULL
  70 #define ARG_EGID                0x0000000000000008ULL
  71 #define ARG_RGID                0x0000000000000010ULL
  72 #define ARG_SGID                0x0000000000000020ULL
  73 #define ARG_PID                 0x0000000000000040ULL
  74 #define ARG_UID                 0x0000000000000080ULL
  75 #define ARG_AUID                0x0000000000000100ULL
  76 #define ARG_GID                 0x0000000000000200ULL
  77 #define ARG_FD                  0x0000000000000400ULL
  78 #define ARG_POSIX_IPC_PERM      0x0000000000000800ULL
  79 #define ARG_FFLAGS              0x0000000000001000ULL
  80 #define ARG_MODE                0x0000000000002000ULL
  81 #define ARG_DEV                 0x0000000000004000ULL
  82 #define ARG_ADDR                0x0000000000008000ULL
  83 #define ARG_LEN                 0x0000000000010000ULL
  84 #define ARG_MASK                0x0000000000020000ULL
  85 #define ARG_SIGNUM              0x0000000000040000ULL
  86 #define ARG_LOGIN               0x0000000000080000ULL
  87 #define ARG_SADDRINET           0x0000000000100000ULL
  88 #define ARG_SADDRINET6          0x0000000000200000ULL
  89 #define ARG_SADDRUNIX           0x0000000000400000ULL
  90 #define ARG_TERMID_ADDR         0x0000000000400000ULL
  91 #define ARG_UNUSED2             0x0000000001000000ULL
  92 #define ARG_UPATH1              0x0000000002000000ULL
  93 #define ARG_UPATH2              0x0000000004000000ULL
  94 #define ARG_TEXT                0x0000000008000000ULL
  95 #define ARG_VNODE1              0x0000000010000000ULL
  96 #define ARG_VNODE2              0x0000000020000000ULL
  97 #define ARG_SVIPC_CMD           0x0000000040000000ULL
  98 #define ARG_SVIPC_PERM          0x0000000080000000ULL
  99 #define ARG_SVIPC_ID            0x0000000100000000ULL
 100 #define ARG_SVIPC_ADDR          0x0000000200000000ULL
 101 #define ARG_GROUPSET            0x0000000400000000ULL
 102 #define ARG_CMD                 0x0000000800000000ULL
 103 #define ARG_SOCKINFO            0x0000001000000000ULL
 104 #define ARG_ASID                0x0000002000000000ULL
 105 #define ARG_TERMID              0x0000004000000000ULL
 106 #define ARG_AUDITON             0x0000008000000000ULL
 107 #define ARG_VALUE               0x0000010000000000ULL
 108 #define ARG_AMASK               0x0000020000000000ULL
 109 #define ARG_CTLNAME             0x0000040000000000ULL
 110 #define ARG_PROCESS             0x0000080000000000ULL
 111 #define ARG_MACHPORT1           0x0000100000000000ULL
 112 #define ARG_MACHPORT2           0x0000200000000000ULL
 113 #define ARG_EXIT                0x0000400000000000ULL
 114 #define ARG_IOVECSTR            0x0000800000000000ULL
 115 #define ARG_ARGV                0x0001000000000000ULL
 116 #define ARG_ENVV                0x0002000000000000ULL
 117 #define ARG_NONE                0x0000000000000000ULL
 118 #define ARG_ALL                 0xFFFFFFFFFFFFFFFFULL
 119
 120 void     audit_syscall_enter(unsigned short code, struct thread *td);
 121 void     audit_syscall_exit(int error, struct thread *td);
 122
 123 /*
 124  * The remaining kernel functions are conditionally compiled in as they are
 125  * wrapped by a macro, and the macro should be the only place in the source
 126  * tree where these functions are referenced.
 127  */
 128 #ifdef AUDIT
 129 struct ipc_perm;
 130 struct sockaddr;
 131 union auditon_udata;
 132 void     audit_arg_addr(void * addr);
 133 void     audit_arg_exit(int status, int retval);
 134 void     audit_arg_len(int len);
 135 void     audit_arg_fd(int fd);
 136 void     audit_arg_fflags(int fflags);
 137 void     audit_arg_gid(gid_t gid);
 138 void     audit_arg_uid(uid_t uid);
 139 void     audit_arg_egid(gid_t egid);
 140 void     audit_arg_euid(uid_t euid);
 141 void     audit_arg_rgid(gid_t rgid);
 142 void     audit_arg_ruid(uid_t ruid);
 143 void     audit_arg_sgid(gid_t sgid);
 144 void     audit_arg_suid(uid_t suid);
 145 void     audit_arg_groupset(gid_t *gidset, u_int gidset_size);
 146 void     audit_arg_login(char *login);
 147 void     audit_arg_ctlname(int *name, int namelen);
 148 void     audit_arg_mask(int mask);
 149 void     audit_arg_mode(mode_t mode);
 150 void     audit_arg_dev(int dev);
 151 void     audit_arg_value(long value);
 152 void     audit_arg_owner(uid_t uid, gid_t gid);
 153 void     audit_arg_pid(pid_t pid);
 154 void     audit_arg_process(struct proc *p);
 155 void     audit_arg_signum(u_int signum);
 156 void     audit_arg_socket(int sodomain, int sotype, int soprotocol);
 157 void     audit_arg_sockaddr(struct thread *td, struct sockaddr *sa);
 158 void     audit_arg_auid(uid_t auid);
 159 void     audit_arg_auditinfo(struct auditinfo *au_info);
 160 void     audit_arg_auditinfo_addr(struct auditinfo_addr *au_info);
 161 void     audit_arg_upath(struct thread *td, char *upath, u_int64_t flags);
 162 void     audit_arg_vnode(struct vnode *vp, u_int64_t flags);
 163 void     audit_arg_text(char *text);
 164 void     audit_arg_cmd(int cmd);
 165 void     audit_arg_svipc_cmd(int cmd);
 166 void     audit_arg_svipc_perm(struct ipc_perm *perm);
 167 void     audit_arg_svipc_id(int id);
 168 void     audit_arg_svipc_addr(void *addr);
 169 void     audit_arg_posix_ipc_perm(uid_t uid, gid_t gid, mode_t mode);
 170 void     audit_arg_auditon(union auditon_udata *udata);
 171 void     audit_arg_file(struct proc *p, struct file *fp);
 172 void     audit_arg_argv(char *argv, int argc, int length);
 173 void     audit_arg_envv(char *envv, int envc, int length);
 174 void     audit_sysclose(struct thread *td, int fd);
 175 void     audit_cred_copy(struct ucred *src, struct ucred *dest);
 176 void     audit_cred_destroy(struct ucred *cred);
 177 void     audit_cred_init(struct ucred *cred);
 178 void     audit_cred_kproc0(struct ucred *cred);
 179 void     audit_cred_proc1(struct ucred *cred);
 180 void     audit_proc_coredump(struct thread *td, char *path, int errcode);
 181 void     audit_thread_alloc(struct thread *td);
 182 void     audit_thread_free(struct thread *td);
 183
 184 /*
 185  * Define a macro to wrap the audit_arg_* calls by checking the global
 186  * audit_enabled flag before performing the actual call.
 187  */
 188 #define AUDIT_ARG(op, args...)  do {                                    \
 189         if (td->td_pflags & TDP_AUDITREC)                               \
 190                 audit_arg_ ## op (args);                                \
 191 } while (0)
 192
 193 #define AUDIT_SYSCALL_ENTER(code, td)   do {                            \
 194         if (audit_enabled) {                                            \
 195                 audit_syscall_enter(code, td);                          \
 196         }                                                               \
 197 } while (0)
 198
 199 /*
 200  * Wrap the audit_syscall_exit() function so that it is called only when
 201  * we have a audit record on the thread.  Audit records can persist after
 202  * auditing is disabled, so we don't just check audit_enabled here.
 203  */
 204 #define AUDIT_SYSCALL_EXIT(error, td)   do {                            \
 205         if (td->td_pflags & TDP_AUDITREC)                               \
 206                 audit_syscall_exit(error, td);                          \
 207 } while (0)
 208
 209 /*
 210  * A Macro to wrap the audit_sysclose() function.
 211  */
 212 #define AUDIT_SYSCLOSE(td, fd)  do {                                    \
 213         if (td->td_pflags & TDP_AUDITREC)                               \
 214                 audit_sysclose(td, fd);                                 \
 215 } while (0)
 216
 217 #else /* !AUDIT */
 218
 219 #define AUDIT_ARG(op, args...)  do {                                    \
 220 } while (0)
 221
 222 #define AUDIT_SYSCALL_ENTER(code, td)   do {                            \
 223 } while (0)
 224
 225 #define AUDIT_SYSCALL_EXIT(error, td)   do {                            \
 226 } while (0)
 227
 228 #define AUDIT_SYSCLOSE(p, fd)   do {                                    \
 229 } while (0)
 230
 231 #endif /* AUDIT */
 232
 233 #endif /* !_SECURITY_AUDIT_KERNEL_H_ */