diff options
Diffstat (limited to 'sys/security/audit')
-rw-r--r-- | sys/security/audit/audit_bsm_errno.c | 642 | ||||
-rw-r--r-- | sys/security/audit/audit_bsm_token.c | 202 |
2 files changed, 767 insertions, 77 deletions
diff --git a/sys/security/audit/audit_bsm_errno.c b/sys/security/audit/audit_bsm_errno.c new file mode 100644 index 0000000..7586213 --- /dev/null +++ b/sys/security/audit/audit_bsm_errno.c @@ -0,0 +1,642 @@ +/*- + * Copyright (c) 2008 Apple Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * P4: //depot/projects/trustedbsd/openbsm/libbsm/bsm_errno.c#12 + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/types.h> + +#include <bsm/audit_errno.h> +#include <bsm/libbsm.h> + +#include <sys/errno.h> + +/* + * Different operating systems use different numeric constants for different + * error numbers, and sometimes error numbers don't exist in more than one + * operating system. These routines convert between BSM and local error + * number spaces, subject to the above realities. BSM error numbers are + * stored in a single 8-bit character, so don't have a byte order. + */ + +struct bsm_errors { + int be_bsm_error; + int be_os_error; + const char *be_strerror; +}; + +#define ERRNO_NO_LOCAL_MAPPING -600 + +/* + * Mapping table -- please maintain in numeric sorted order with respect to + * the BSM constant. Today we do a linear lookup, but could switch to a + * binary search if it makes sense. We only ifdef errors that aren't + * generally available, but it does make the table a lot more ugly. + * + * XXXRW: It would be nice to have a similar ordered table mapping to BSM + * constant from local constant, but the order of local constants varies by + * OS. Really we need to build that table at compile-time but don't do that + * yet. + * + * XXXRW: We currently embed English-language error strings here, but should + * support catalogues; these are only used if the OS doesn't have an error + * string using strerror(3). + */ +static const struct bsm_errors bsm_errors[] = { + { BSM_ESUCCESS, 0, "Success" }, + { BSM_EPERM, EPERM, "Operation not permitted" }, + { BSM_ENOENT, ENOENT, "No such file or directory" }, + { BSM_ESRCH, ESRCH, "No such process" }, + { BSM_EINTR, EINTR, "Interrupted system call" }, + { BSM_EIO, EIO, "Input/output error" }, + { BSM_ENXIO, ENXIO, "Device not configured" }, + { BSM_E2BIG, E2BIG, "Argument list too long" }, + { BSM_ENOEXEC, ENOEXEC, "Exec format error" }, + { BSM_EBADF, EBADF, "BAd file descriptor" }, + { BSM_ECHILD, ECHILD, "No child processes" }, + { BSM_EAGAIN, EAGAIN, "Resource temporarily unavailable" }, + { BSM_ENOMEM, ENOMEM, "Cannot allocate memory" }, + { BSM_EACCES, EACCES, "Permission denied" }, + { BSM_EFAULT, EFAULT, "Bad address" }, + { BSM_ENOTBLK, ENOTBLK, "Block device required" }, + { BSM_EBUSY, EBUSY, "Device busy" }, + { BSM_EEXIST, EEXIST, "File exists" }, + { BSM_EXDEV, EXDEV, "Cross-device link" }, + { BSM_ENODEV, ENODEV, "Operation not supported by device" }, + { BSM_ENOTDIR, ENOTDIR, "Not a directory" }, + { BSM_EISDIR, EISDIR, "Is a directory" }, + { BSM_EINVAL, EINVAL, "Invalid argument" }, + { BSM_ENFILE, ENFILE, "Too many open files in system" }, + { BSM_EMFILE, EMFILE, "Too many open files" }, + { BSM_ENOTTY, ENOTTY, "Inappropriate ioctl for device" }, + { BSM_ETXTBSY, ETXTBSY, "Text file busy" }, + { BSM_EFBIG, EFBIG, "File too large" }, + { BSM_ENOSPC, ENOSPC, "No space left on device" }, + { BSM_ESPIPE, ESPIPE, "Illegal seek" }, + { BSM_EROFS, EROFS, "Read-only file system" }, + { BSM_EMLINK, EMLINK, "Too many links" }, + { BSM_EPIPE, EPIPE, "Broken pipe" }, + { BSM_EDOM, EDOM, "Numerical argument out of domain" }, + { BSM_ERANGE, ERANGE, "Result too large" }, + { BSM_ENOMSG, ENOMSG, "No message of desired type" }, + { BSM_EIDRM, EIDRM, "Identifier removed" }, + { BSM_ECHRNG, +#ifdef ECHRNG + ECHRNG, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Channel number out of range" }, + { BSM_EL2NSYNC, +#ifdef EL2NSYNC + EL2NSYNC, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Level 2 not synchronized" }, + { BSM_EL3HLT, +#ifdef EL3HLT + EL3HLT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Level 3 halted" }, + { BSM_EL3RST, +#ifdef EL3RST + EL3RST, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Level 3 reset" }, + { BSM_ELNRNG, +#ifdef ELNRNG + ELNRNG, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Link number out of range" }, + { BSM_EUNATCH, +#ifdef EUNATCH + EUNATCH, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Protocol driver not attached" }, + { BSM_ENOCSI, +#ifdef ENOCSI + ENOCSI, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "No CSI structure available" }, + { BSM_EL2HLT, +#ifdef EL2HLT + EL2HLT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Level 2 halted" }, + { BSM_EDEADLK, EDEADLK, "Resource deadlock avoided" }, + { BSM_ENOLCK, ENOLCK, "No locks available" }, + { BSM_ECANCELED, ECANCELED, "Operation canceled" }, + { BSM_ENOTSUP, ENOTSUP, "Operation not supported" }, + { BSM_EDQUOT, EDQUOT, "Disc quota exceeded" }, + { BSM_EBADE, +#ifdef EBADE + EBADE, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Invalid exchange" }, + { BSM_EBADR, +#ifdef EBADR + EBADR, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Invalid request descriptor" }, + { BSM_EXFULL, +#ifdef EXFULL + EXFULL, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Exchange full" }, + { BSM_ENOANO, +#ifdef ENOANO + ENOANO, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "No anode" }, + { BSM_EBADRQC, +#ifdef EBADRQC + EBADRQC, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Invalid request descriptor" }, + { BSM_EBADSLT, +#ifdef EBADSLT + EBADSLT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Invalid slot" }, + { BSM_EDEADLOCK, +#ifdef EDEADLOCK + EDEADLOCK, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Resource deadlock avoided" }, + { BSM_EBFONT, +#ifdef EBFONT + EBFONT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Bad font file format" }, + { BSM_EOWNERDEAD, +#ifdef EOWNERDEAD + EOWNERDEAD, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Process died with the lock" }, + { BSM_ENOTRECOVERABLE, +#ifdef ENOTRECOVERABLE + ENOTRECOVERABLE, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Lock is not recoverable" }, + { BSM_ENOSTR, +#ifdef ENOSTR + ENOSTR, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Device not a stream" }, + { BSM_ENONET, +#ifdef ENONET + ENONET, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Machine is not on the network" }, + { BSM_ENOPKG, +#ifdef ENOPKG + ENOPKG, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Package not installed" }, + { BSM_EREMOTE, EREMOTE, "Too many levels of remote in path" }, + { BSM_ENOLINK, +#ifdef ENOLINK + ENOLINK, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Link has been severed" }, + { BSM_EADV, +#ifdef EADV + EADV, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Advertise error" }, + { BSM_ESRMNT, +#ifdef ESRMNT + ESRMNT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "srmount error" }, + { BSM_ECOMM, +#ifdef ECOMM + ECOMM, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Communication error on send" }, + { BSM_EPROTO, +#ifdef EPROTO + EPROTO, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Protocol error" }, + { BSM_ELOCKUNMAPPED, +#ifdef ELOCKUNMAPPED + ELOCKUNMAPPED, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Locked lock was unmapped" }, + { BSM_ENOTACTIVE, +#ifdef ENOTACTIVE + ENOTACTIVE, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Facility is not active" }, + { BSM_EMULTIHOP, +#ifdef EMULTIHOP + EMULTIHOP, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Multihop attempted" }, + { BSM_EBADMSG, +#ifdef EBADMSG + EBADMSG, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Bad message" }, + { BSM_ENAMETOOLONG, ENAMETOOLONG, "File name too long" }, + { BSM_EOVERFLOW, EOVERFLOW, "Value too large to be stored in data type" }, + { BSM_ENOTUNIQ, +#ifdef ENOTUNIQ + ENOTUNIQ, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Given log name not unique" }, + { BSM_EBADFD, +#ifdef EBADFD + EBADFD, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Given f.d. invalid for this operation" }, + { BSM_EREMCHG, +#ifdef EREMCHG + EREMCHG, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Remote address changed" }, + { BSM_ELIBACC, +#ifdef ELIBACC + ELIBACC, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Can't access a needed shared lib" }, + { BSM_ELIBBAD, +#ifdef ELIBBAD + ELIBBAD, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Accessing a corrupted shared lib" }, + { BSM_ELIBSCN, +#ifdef ELIBSCN + ELIBSCN, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + ".lib section in a.out corrupted" }, + { BSM_ELIBMAX, +#ifdef ELIBMAX + ELIBMAX, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Attempting to link in too many libs" }, + { BSM_ELIBEXEC, +#ifdef ELIBEXEC + ELIBEXEC, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Attempting to exec a shared library" }, + { BSM_EILSEQ, EILSEQ, "Illegal byte sequence" }, + { BSM_ENOSYS, ENOSYS, "Function not implemented" }, + { BSM_ELOOP, ELOOP, "Too many levels of symbolic links" }, + { BSM_ERESTART, +#ifdef ERESTART + ERESTART, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Restart syscall" }, + { BSM_ESTRPIPE, +#ifdef ESTRPIPE + ESTRPIPE, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "If pipe/FIFO, don't sleep in stream head" }, + { BSM_ENOTEMPTY, ENOTEMPTY, "Directory not empty" }, + { BSM_EUSERS, EUSERS, "Too many users" }, + { BSM_ENOTSOCK, ENOTSOCK, "Socket operation on non-socket" }, + { BSM_EDESTADDRREQ, EDESTADDRREQ, "Destination address required" }, + { BSM_EMSGSIZE, EMSGSIZE, "Message too long" }, + { BSM_EPROTOTYPE, EPROTOTYPE, "Protocol wrong type for socket" }, + { BSM_ENOPROTOOPT, ENOPROTOOPT, "Protocol not available" }, + { BSM_EPROTONOSUPPORT, EPROTONOSUPPORT, "Protocol not supported" }, + { BSM_ESOCKTNOSUPPORT, ESOCKTNOSUPPORT, "Socket type not supported" }, + { BSM_EOPNOTSUPP, EOPNOTSUPP, "Operation not supported" }, + { BSM_EPFNOSUPPORT, EPFNOSUPPORT, "Protocol family not supported" }, + { BSM_EAFNOSUPPORT, EAFNOSUPPORT, "Address family not supported by protocol family" }, + { BSM_EADDRINUSE, EADDRINUSE, "Address already in use" }, + { BSM_EADDRNOTAVAIL, EADDRNOTAVAIL, "Can't assign requested address" }, + { BSM_ENETDOWN, ENETDOWN, "Network is down" }, + { BSM_ENETRESET, ENETRESET, "Network dropped connection on reset" }, + { BSM_ECONNABORTED, ECONNABORTED, "Software caused connection abort" }, + { BSM_ECONNRESET, ECONNRESET, "Connection reset by peer" }, + { BSM_ENOBUFS, ENOBUFS, "No buffer space available" }, + { BSM_EISCONN, EISCONN, "Socket is already connected" }, + { BSM_ENOTCONN, ENOTCONN, "Socket is not connected" }, + { BSM_ESHUTDOWN, ESHUTDOWN, "Can't send after socket shutdown" }, + { BSM_ETOOMANYREFS, ETOOMANYREFS, "Too many references: can't splice" }, + { BSM_ETIMEDOUT, ETIMEDOUT, "Operation timed out" }, + { BSM_ECONNREFUSED, ECONNREFUSED, "Connection refused" }, + { BSM_EHOSTDOWN, EHOSTDOWN, "Host is down" }, + { BSM_EHOSTUNREACH, EHOSTUNREACH, "No route to host" }, + { BSM_EALREADY, EALREADY, "Operation already in progress" }, + { BSM_EINPROGRESS, EINPROGRESS, "Operation now in progress" }, + { BSM_ESTALE, ESTALE, "Stale NFS file handle" }, + { BSM_EPWROFF, +#ifdef EPWROFF + EPWROFF, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Device power is off" }, + { BSM_EDEVERR, +#ifdef EDEVERR + EDEVERR, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Device error" }, + { BSM_EBADEXEC, +#ifdef EBADEXEC + EBADEXEC, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Bad executable" }, + { BSM_EBADARCH, +#ifdef EBADARCH + EBADARCH, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Bad CPU type in executable" }, + { BSM_ESHLIBVERS, +#ifdef ESHLIBVERS + ESHLIBVERS, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Shared library version mismatch" }, + { BSM_EBADMACHO, +#ifdef EBADMACHO + EBADMACHO, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Malfored Macho file" }, + { BSM_EPOLICY, +#ifdef EPOLICY + EPOLICY, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Operation failed by policy" }, + { BSM_EDOTDOT, +#ifdef EDOTDOT + EDOTDOT, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "RFS specific error" }, + { BSM_EUCLEAN, +#ifdef EUCLEAN + EUCLEAN, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Structure needs cleaning" }, + { BSM_ENOTNAM, +#ifdef ENOTNAM + ENOTNAM, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Not a XENIX named type file" }, + { BSM_ENAVAIL, +#ifdef ENAVAIL + ENAVAIL, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "No XENIX semaphores available" }, + { BSM_EISNAM, +#ifdef EISNAM + EISNAM, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Is a named type file" }, + { BSM_EREMOTEIO, +#ifdef EREMOTEIO + EREMOTEIO, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Remote I/O error" }, + { BSM_ENOMEDIUM, +#ifdef ENOMEDIUM + ENOMEDIUM, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "No medium found" }, + { BSM_EMEDIUMTYPE, +#ifdef EMEDIUMTYPE + EMEDIUMTYPE, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Wrong medium type" }, + { BSM_ENOKEY, +#ifdef ENOKEY + ENOKEY, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Required key not available" }, + { BSM_EKEYEXPIRED, +#ifdef EKEEXPIRED + EKEYEXPIRED, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Key has expired" }, + { BSM_EKEYREVOKED, +#ifdef EKEYREVOKED + EKEYREVOKED, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Key has been revoked" }, + { BSM_EKEYREJECTED, +#ifdef EKEREJECTED + EKEYREJECTED, +#else + ERRNO_NO_LOCAL_MAPPING, +#endif + "Key was rejected by service" }, +}; +static const int bsm_errors_count = sizeof(bsm_errors) / sizeof(bsm_errors[0]); + +static const struct bsm_errors * +au_bsm_error_lookup_errno(int error) +{ + int i; + + if (error == ERRNO_NO_LOCAL_MAPPING) + return (NULL); + for (i = 0; i < bsm_errors_count; i++) { + if (bsm_errors[i].be_os_error == error) + return (&bsm_errors[i]); + } + return (NULL); +} + +static const struct bsm_errors * +au_bsm_error_lookup_bsm(u_char bsm_error) +{ + int i; + + for (i = 0; i < bsm_errors_count; i++) { + if (bsm_errors[i].be_bsm_error == bsm_error) + return (&bsm_errors[i]); + } + return (NULL); +} + +/* + * Converstion from a BSM error to a local error number may fail if either + * OpenBSM doesn't recognize the error on the wire, or because there is no + * appropriate local mapping. However, we don't allow conversion to BSM to + * fail, we just convert to BSM_UKNOWNERR. + */ +int +au_bsm_to_errno(u_char bsm_error, int *errorp) +{ + const struct bsm_errors *bsme; + + bsme = au_bsm_error_lookup_bsm(bsm_error); + if (bsme == NULL || bsme->be_os_error == ERRNO_NO_LOCAL_MAPPING) + return (-1); + *errorp = bsme->be_os_error; + return (0); +} + +u_char +au_errno_to_bsm(int error) +{ + const struct bsm_errors *bsme; + + /* + * We should never be passed this libbsm-internal constant, and + * because it is ambiguous we just return an error. + */ + if (error == ERRNO_NO_LOCAL_MAPPING) + return (BSM_UNKNOWNERR); + bsme = au_bsm_error_lookup_errno(error); + if (bsme == NULL) + return (BSM_UNKNOWNERR); + return (bsme->be_bsm_error); +} + +#if !defined(KERNEL) && !defined(_KERNEL) +const char * +au_strerror(u_char bsm_error) +{ + const struct bsm_errors *bsme; + + bsme = au_bsm_error_lookup_bsm(bsm_error); + if (bsme == NULL) + return ("Unrecognized BSM error"); + if (bsme->be_os_error != ERRNO_NO_LOCAL_MAPPING) + return (strerror(bsme->be_os_error)); + return (bsme->be_strerror); +} +#endif diff --git a/sys/security/audit/audit_bsm_token.c b/sys/security/audit/audit_bsm_token.c index b1d977d..6733030 100644 --- a/sys/security/audit/audit_bsm_token.c +++ b/sys/security/audit/audit_bsm_token.c @@ -147,8 +147,12 @@ au_to_attr32(struct vnode_au_info *vni) ADD_U_CHAR(dptr, AUT_ATTR32); /* - * Darwin defines the size for the file mode as 2 bytes; BSM defines - * 4 so pad with 0. + * BSD defines the size for the file mode as 2 bytes; BSM defines 4 + * so pad with 0. + * + * XXXRW: Possibly should be conditionally compiled. + * + * XXXRW: Should any conversions take place on the mode? */ ADD_U_INT16(dptr, pad0_16); ADD_U_INT16(dptr, vni->vn_mode); @@ -190,8 +194,12 @@ au_to_attr64(struct vnode_au_info *vni) ADD_U_CHAR(dptr, AUT_ATTR64); /* - * Darwin defines the size for the file mode as 2 bytes; BSM defines - * 4 so pad with 0. + * BSD defines the size for the file mode as 2 bytes; BSM defines 4 + * so pad with 0. + * + * XXXRW: Possibly should be conditionally compiled. + * + * XXXRW: Should any conversions take place on the mode? */ ADD_U_INT16(dptr, pad0_16); ADD_U_INT16(dptr, vni->vn_mode); @@ -269,6 +277,10 @@ au_to_data(char unit_print, char unit_type, char unit_count, const char *p) GET_TOKEN_AREA(t, dptr, 4 * sizeof(u_char) + totdata); + /* + * XXXRW: We should be byte-swapping each data item for multi-byte + * types. + */ ADD_U_CHAR(dptr, AUT_DATA); ADD_U_CHAR(dptr, unit_print); ADD_U_CHAR(dptr, unit_type); @@ -432,25 +444,36 @@ au_to_ipc_perm(struct ipc_perm *perm) ADD_U_CHAR(dptr, AUT_IPC_PERM); /* - * Darwin defines the sizes for ipc_perm members as 2 bytes; BSM - * defines 4 so pad with 0. + * Systems vary significantly in what types they use in struct + * ipc_perm; at least a few still use 16-bit uid's and gid's, so + * allow for that, as BSM define 32-bit values here. + * Some systems define the sizes for ipc_perm members as 2 bytes; + * BSM defines 4 so pad with 0. + * + * XXXRW: Possibly shoulid be conditionally compiled, and more cases + * need to be handled. */ - ADD_U_INT16(dptr, pad0); - ADD_U_INT16(dptr, perm->uid); - - ADD_U_INT16(dptr, pad0); - ADD_U_INT16(dptr, perm->gid); - - ADD_U_INT16(dptr, pad0); - ADD_U_INT16(dptr, perm->cuid); - - ADD_U_INT16(dptr, pad0); - ADD_U_INT16(dptr, perm->cgid); + if (sizeof(perm->uid) != sizeof(u_int32_t)) { + ADD_U_INT16(dptr, pad0); + ADD_U_INT16(dptr, perm->uid); + ADD_U_INT16(dptr, pad0); + ADD_U_INT16(dptr, perm->gid); + ADD_U_INT16(dptr, pad0); + ADD_U_INT16(dptr, perm->cuid); + ADD_U_INT16(dptr, pad0); + ADD_U_INT16(dptr, perm->cgid); + } else { + ADD_U_INT32(dptr, perm->uid); + ADD_U_INT32(dptr, perm->gid); + ADD_U_INT32(dptr, perm->cuid); + ADD_U_INT32(dptr, perm->cgid); + } ADD_U_INT16(dptr, pad0); ADD_U_INT16(dptr, perm->mode); ADD_U_INT16(dptr, pad0); + ADD_U_INT16(dptr, perm->seq); ADD_U_INT32(dptr, perm->key); @@ -543,6 +566,8 @@ au_to_text(const char *text) textlen = strlen(text); textlen += 1; + /* XXXRW: Should validate length against token size limit. */ + GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen); ADD_U_CHAR(dptr, AUT_TEXT); @@ -607,6 +632,13 @@ au_to_process32(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, ADD_U_INT32(dptr, pid); ADD_U_INT32(dptr, sid); ADD_U_INT32(dptr, tid->port); + + /* + * Note: Solaris will write out IPv6 addresses here as a 32-bit + * address type and 16 bytes of address, but for IPv4 addresses it + * simply writes the 4-byte address directly. We support only IPv4 + * addresses for process32 tokens. + */ ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t)); return (t); @@ -631,6 +663,13 @@ au_to_process64(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, ADD_U_INT32(dptr, pid); ADD_U_INT32(dptr, sid); ADD_U_INT64(dptr, tid->port); + + /* + * Note: Solaris will write out IPv6 addresses here as a 32-bit + * address type and 16 bytes of address, but for IPv4 addresses it + * simply writes the 4-byte address directly. We support only IPv4 + * addresses for process64 tokens. + */ ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t)); return (t); @@ -805,22 +844,60 @@ au_to_seq(long audit_count) /* * token ID 1 byte + * socket domain 2 bytes * socket type 2 bytes + * address type 2 byte * local port 2 bytes - * local Internet address 4 bytes + * local address 4 bytes/16 bytes (IPv4/IPv6 address) * remote port 2 bytes - * remote Internet address 4 bytes + * remote address 4 bytes/16 bytes (IPv4/IPv6 address) */ token_t * -au_to_socket(struct socket *so) +au_to_socket_ex(u_short so_domain, u_short so_type, + struct sockaddr *sa_local, struct sockaddr *sa_remote) { + token_t *t; + u_char *dptr = NULL; + struct sockaddr_in *sin; + struct sockaddr_in6 *sin6; + + if (so_domain == AF_INET) + GET_TOKEN_AREA(t, dptr, sizeof(u_char) + + 5 * sizeof(u_int16_t) + 2 * sizeof(u_int32_t)); + else if (so_domain == AF_INET6) + GET_TOKEN_AREA(t, dptr, sizeof(u_char) + + 5 * sizeof(u_int16_t) + 16 * sizeof(u_int32_t)); + else + return (NULL); + + ADD_U_CHAR(dptr, AUT_SOCKET_EX); + ADD_U_INT16(dptr, so_domain); /* XXXRW: explicitly convert? */ + ADD_U_INT16(dptr, so_type); /* XXXRW: explicitly convert? */ + if (so_domain == AF_INET) { + ADD_U_INT16(dptr, AU_IPv4); + sin = (struct sockaddr_in *)sa_local; + ADD_MEM(dptr, &sin->sin_port, sizeof(uint16_t)); + ADD_MEM(dptr, &sin->sin_addr.s_addr, sizeof(uint32_t)); + sin = (struct sockaddr_in *)sa_remote; + ADD_MEM(dptr, &sin->sin_port, sizeof(uint16_t)); + ADD_MEM(dptr, &sin->sin_addr.s_addr, sizeof(uint32_t)); + } else { + ADD_U_INT16(dptr, AU_IPv6); + sin6 = (struct sockaddr_in6 *)sa_local; + ADD_MEM(dptr, &sin6->sin6_port, sizeof(uint16_t)); + ADD_MEM(dptr, &sin6->sin6_addr, 4 * sizeof(uint32_t)); + sin6 = (struct sockaddr_in6 *)sa_remote; + ADD_MEM(dptr, &sin6->sin6_port, sizeof(uint16_t)); + ADD_MEM(dptr, &sin6->sin6_addr, 4 * sizeof(uint32_t)); + } - /* XXXRW ... */ - return (NULL); + return (t); } /* * Kernel-specific version of the above function. + * + * XXXRW: Should now use au_to_socket_ex() here. */ #ifdef _KERNEL token_t * @@ -832,7 +909,7 @@ kau_to_socket(struct socket_au_info *soi) GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) + sizeof(u_int32_t) + sizeof(u_int16_t) + sizeof(u_int32_t)); - + ADD_U_CHAR(dptr, AUT_SOCKET); /* Coerce the socket type into a short value */ so_type = soi->so_type; @@ -848,32 +925,6 @@ kau_to_socket(struct socket_au_info *soi) /* * token ID 1 byte - * socket type 2 bytes - * local port 2 bytes - * address type/length 4 bytes - * local Internet address 4 bytes/16 bytes (IPv4/IPv6 address) - * remote port 4 bytes - * address type/length 4 bytes - * remote Internet address 4 bytes/16 bytes (IPv4/IPv6 address) - */ -token_t * -au_to_socket_ex_32(u_int16_t lp, u_int16_t rp, struct sockaddr *la, - struct sockaddr *ra) -{ - - return (NULL); -} - -token_t * -au_to_socket_ex_128(u_int16_t lp, u_int16_t rp, struct sockaddr *la, - struct sockaddr *ra) -{ - - return (NULL); -} - -/* - * token ID 1 byte * socket family 2 bytes * path 104 bytes */ @@ -940,8 +991,9 @@ au_to_sock_inet128(struct sockaddr_in6 *so) ADD_U_CHAR(dptr, AUT_SOCKINET128); /* - * In Darwin, sin6_family is one octet, but BSM defines the token - * to store two. So we copy in a 0 first. + * In BSD, sin6_family is one octet, but BSM defines the token to + * store two. So we copy in a 0 first. XXXRW: Possibly should be + * conditionally compiled. */ ADD_U_CHAR(dptr, 0); ADD_U_CHAR(dptr, so->sin6_family); @@ -1215,7 +1267,6 @@ au_to_exec_args(char **argv) nextarg = *(argv + count); } - totlen += count * sizeof(char); /* nul terminations. */ GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen); ADD_U_CHAR(dptr, AUT_EXEC_ARGS); @@ -1228,30 +1279,7 @@ au_to_exec_args(char **argv) return (t); } -#endif - -/* - * token ID 1 byte - * zonename length 2 bytes - * zonename N bytes + 1 terminating NULL byte - */ -token_t * -au_to_zonename(const char *zonename) -{ - u_char *dptr = NULL; - u_int16_t textlen; - token_t *t; - - textlen = strlen(zonename); - textlen += 1; - GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen); - ADD_U_CHAR(dptr, AUT_ZONENAME); - ADD_U_INT16(dptr, textlen); - ADD_STRING(dptr, zonename, textlen); - return (t); -} -#if !defined(_KERNEL) && !defined(KERNEL) /* * token ID 1 byte * count 4 bytes @@ -1277,7 +1305,6 @@ au_to_exec_env(char **envp) nextenv = *(envp + count); } - totlen += sizeof(char) * count; GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen); ADD_U_CHAR(dptr, AUT_EXEC_ENV); @@ -1294,6 +1321,27 @@ au_to_exec_env(char **envp) /* * token ID 1 byte + * zonename length 2 bytes + * zonename N bytes + 1 terminating NULL byte + */ +token_t * +au_to_zonename(const char *zonename) +{ + u_char *dptr = NULL; + u_int16_t textlen; + token_t *t; + + textlen = strlen(zonename) + 1; + GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen); + + ADD_U_CHAR(dptr, AUT_ZONENAME); + ADD_U_INT16(dptr, textlen); + ADD_STRING(dptr, zonename, textlen); + return (t); +} + +/* + * token ID 1 byte * record byte count 4 bytes * version # 1 byte [2] * event type 2 bytes @@ -1465,7 +1513,7 @@ au_to_trailer(int rec_size) { token_t *t; u_char *dptr = NULL; - u_int16_t magic = TRAILER_PAD_MAGIC; + u_int16_t magic = AUT_TRAILER_MAGIC; GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + sizeof(u_int32_t)); |