diff options
Diffstat (limited to '')
| -rw-r--r-- | plugins/sudoers/iolog.c | 1367 |
1 files changed, 1367 insertions, 0 deletions
diff --git a/plugins/sudoers/iolog.c b/plugins/sudoers/iolog.c new file mode 100644 index 0000000..ec93698 --- /dev/null +++ b/plugins/sudoers/iolog.c @@ -0,0 +1,1367 @@ +/* + * SPDX-License-Identifier: ISC + * + * Copyright (c) 2009-2022 Todd C. Miller <Todd.Miller@sudo.ws> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * This is an open source non-commercial project. Dear PVS-Studio, please check it. + * PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com + */ + +#include <config.h> + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <pwd.h> +#include <grp.h> +#include <arpa/inet.h> +#include <netinet/in.h> + +#include "sudoers.h" +#include "sudo_eventlog.h" +#include "sudo_iolog.h" +#include "strlist.h" +#ifdef SUDOERS_LOG_CLIENT +# include "log_client.h" +#endif + +static struct iolog_file iolog_files[] = { + { false }, /* IOFD_STDIN */ + { false }, /* IOFD_STDOUT */ + { false }, /* IOFD_STDERR */ + { false }, /* IOFD_TTYIN */ + { false }, /* IOFD_TTYOUT */ + { true, }, /* IOFD_TIMING */ +}; + +static struct sudoers_io_operations { + int (*open)(struct timespec *now); + void (*close)(int exit_status, int error, const char **errstr); + int (*log)(int event, const char *buf, unsigned int len, + struct timespec *delay, const char **errstr); + int (*change_winsize)(unsigned int lines, unsigned int cols, + struct timespec *delay, const char **errstr); + int (*suspend)(const char *signame, struct timespec *delay, + const char **errstr); +} io_operations; + +static struct log_details iolog_details; +static bool warned = false; +static bool log_passwords = true; +static int iolog_dir_fd = -1; +static struct timespec last_time; +static void *passprompt_regex_handle; +static void sudoers_io_setops(void); + +/* sudoers_io is declared at the end of this file. */ +extern sudo_dso_public struct io_plugin sudoers_io; + +/* + * Sudoers callback for maxseq Defaults setting. + */ +bool +cb_maxseq(const char *file, int line, int column, + const union sudo_defs_val *sd_un, int op) +{ + const char *errstr; + unsigned int value; + debug_decl(cb_maxseq, SUDOERS_DEBUG_UTIL); + + value = sudo_strtonum(sd_un->str, 0, SESSID_MAX, &errstr); + if (errstr != NULL) { + if (errno != ERANGE) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO, + "bad maxseq: %s: %s", sd_un->str, errstr); + debug_return_bool(false); + } + /* Out of range, clamp to SESSID_MAX as documented. */ + value = SESSID_MAX; + } + iolog_set_maxseq(value); + debug_return_bool(true); +} + +/* + * Sudoers callback for iolog_user Defaults setting. + */ +bool +cb_iolog_user(const char *file, int line, int column, + const union sudo_defs_val *sd_un, int op) +{ + const char *name = sd_un->str; + struct passwd *pw; + debug_decl(cb_iolog_user, SUDOERS_DEBUG_UTIL); + + /* NULL name means reset to default. */ + if (name == NULL) { + iolog_set_owner(ROOT_UID, ROOT_GID); + } else { + if ((pw = sudo_getpwnam(name)) == NULL) { + log_warningx(SLOG_SEND_MAIL, N_("unknown user %s"), name); + debug_return_bool(false); + } + iolog_set_owner(pw->pw_uid, pw->pw_gid); + sudo_pw_delref(pw); + } + + debug_return_bool(true); +} + +/* + * Look up I/O log group-ID from group name. + */ +bool +cb_iolog_group(const char *file, int line, int column, + const union sudo_defs_val *sd_un, int op) +{ + const char *name = sd_un->str; + struct group *gr; + debug_decl(cb_iolog_group, SUDOERS_DEBUG_UTIL); + + /* NULL name means reset to default. */ + if (name == NULL) { + iolog_set_gid(ROOT_GID); + } else { + if ((gr = sudo_getgrnam(name)) == NULL) { + log_warningx(SLOG_SEND_MAIL, N_("unknown group %s"), name); + debug_return_bool(false); + } + iolog_set_gid(gr->gr_gid); + sudo_gr_delref(gr); + } + + debug_return_bool(true); +} + +/* + * Sudoers callback for iolog_mode Defaults setting. + */ +bool +cb_iolog_mode(const char *file, int line, int column, + const union sudo_defs_val *sd_un, int op) +{ + iolog_set_mode(sd_un->mode); + return true; +} + +/* + * Make a shallow copy of a NULL-terminated argument or environment vector. + * Only the outer array is allocated, the pointers inside are copied. + * The caller is responsible for freeing the returned copy. + */ +static char ** +copy_vector_shallow(char * const *vec) +{ + char **copy; + size_t len; + debug_decl(copy_vector, SUDOERS_DEBUG_UTIL); + + for (len = 0; vec[len] != NULL; len++) + continue; + + if ((copy = reallocarray(NULL, len + 1, sizeof(char *))) != NULL) { + for (len = 0; vec[len] != NULL; len++) + copy[len] = vec[len]; + copy[len] = NULL; + } + + debug_return_ptr(copy); +} + +static void +free_iolog_details(void) +{ + debug_decl(free_iolog_details, SUDOERS_DEBUG_PLUGIN); + + if (iolog_details.evlog != NULL) { + /* We only make a shallow copy of argv and envp. */ + free(iolog_details.evlog->argv); + iolog_details.evlog->argv = NULL; + free(iolog_details.evlog->envp); + iolog_details.evlog->envp = NULL; + eventlog_free(iolog_details.evlog); + } + str_list_free(iolog_details.log_servers); +#if defined(HAVE_OPENSSL) + free(iolog_details.ca_bundle); + free(iolog_details.cert_file); + free(iolog_details.key_file); +#endif /* HAVE_OPENSSL */ + + debug_return; +} + +/* + * Convert a comma-separated list to a string list. + */ +static struct sudoers_str_list * +deserialize_stringlist(const char *s) +{ + struct sudoers_str_list *strlist; + struct sudoers_string *str; + const char *s_end = s + strlen(s); + const char *cp, *ep; + debug_decl(deserialize_stringlist, SUDOERS_DEBUG_UTIL); + + if ((strlist = str_list_alloc()) == NULL) + debug_return_ptr(NULL); + + for (cp = sudo_strsplit(s, s_end, ",", &ep); cp != NULL; + cp = sudo_strsplit(NULL, s_end, ",", &ep)) { + if (cp == ep) + continue; + if ((str = malloc(sizeof(*str))) == NULL) + goto bad; + if ((str->str = strndup(cp, (ep - cp))) == NULL) { + free(str); + goto bad; + } + unescape_string(str->str); + STAILQ_INSERT_TAIL(strlist, str, entries); + } + if (STAILQ_EMPTY(strlist)) + goto bad; + + debug_return_ptr(strlist); + +bad: + str_list_free(strlist); + debug_return_ptr(NULL); +} + +/* + * Set passprompt regex filter based on a comma-separated string. + * Returns a passprompt regex handle pointer. + */ +static void * +set_passprompt_regex(const char *cstr) +{ + void *handle; + char *cp, *str, *last = NULL; + debug_decl(set_passprompt_regex, SUDOERS_DEBUG_UTIL); + + handle = iolog_pwfilt_alloc(); + str = strdup(cstr); + if (handle == NULL || str == NULL) { + sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory")); + goto bad; + } + + for ((cp = strtok_r(str, ",", &last)); cp != NULL; + (cp = strtok_r(NULL, ",", &last))) { + unescape_string(cp); + if (!iolog_pwfilt_add(handle, cp)) + goto bad; + } + + free(str); + debug_return_ptr(handle); +bad: + free(str); + iolog_pwfilt_free(handle); + debug_return_ptr(NULL); +} + +/* + * Pull out I/O log related data from user_info and command_info arrays. + * Returns true if I/O logging is enabled, false if not and -1 on error. + */ +static int +iolog_deserialize_info(struct log_details *details, char * const user_info[], + char * const command_info[], char * const argv[], char * const user_env[]) +{ + struct eventlog *evlog; + const char *runas_uid_str = "0", *runas_euid_str = NULL; + const char *runas_gid_str = "0", *runas_egid_str = NULL; + const char *errstr; + char idbuf[MAX_UID_T_LEN + 2]; + char * const *cur; + struct passwd *pw; + struct group *gr; + id_t id; + debug_decl(iolog_deserialize_info, SUDOERS_DEBUG_UTIL); + + if ((evlog = calloc(1, sizeof(*evlog))) == NULL) + goto oom; + details->evlog = evlog; + + evlog->lines = 24; + evlog->columns = 80; + evlog->runuid = ROOT_UID; + evlog->rungid = 0; + sudo_gettime_real(&evlog->submit_time); + + for (cur = user_info; *cur != NULL; cur++) { + switch (**cur) { + case 'c': + if (strncmp(*cur, "cols=", sizeof("cols=") - 1) == 0) { + int n = sudo_strtonum(*cur + sizeof("cols=") - 1, 1, INT_MAX, + NULL); + if (n > 0) + evlog->columns = n; + continue; + } + if (strncmp(*cur, "cwd=", sizeof("cwd=") - 1) == 0) { + free(evlog->cwd); + evlog->cwd = strdup(*cur + sizeof("cwd=") - 1); + if (evlog->cwd == NULL) + goto oom; + continue; + } + break; + case 'h': + if (strncmp(*cur, "host=", sizeof("host=") - 1) == 0) { + free(evlog->submithost); + evlog->submithost = strdup(*cur + sizeof("host=") - 1); + if (evlog->submithost == NULL) + goto oom; + continue; + } + break; + case 'l': + if (strncmp(*cur, "lines=", sizeof("lines=") - 1) == 0) { + int n = sudo_strtonum(*cur + sizeof("lines=") - 1, 1, INT_MAX, + NULL); + if (n > 0) + evlog->lines = n; + continue; + } + break; + case 't': + if (strncmp(*cur, "tty=", sizeof("tty=") - 1) == 0) { + free(evlog->ttyname); + evlog->ttyname = strdup(*cur + sizeof("tty=") - 1); + if (evlog->ttyname == NULL) + goto oom; + continue; + } + break; + case 'u': + if (strncmp(*cur, "user=", sizeof("user=") - 1) == 0) { + free(evlog->submituser); + evlog->submituser = strdup(*cur + sizeof("user=") - 1); + if (evlog->submituser == NULL) + goto oom; + continue; + } + break; + } + } + + for (cur = command_info; *cur != NULL; cur++) { + switch (**cur) { + case 'c': + if (strncmp(*cur, "command=", sizeof("command=") - 1) == 0) { + free(evlog->command); + evlog->command = strdup(*cur + sizeof("command=") - 1); + if (evlog->command == NULL) + goto oom; + continue; + } + if (strncmp(*cur, "chroot=", sizeof("chroot=") - 1) == 0) { + free(evlog->runchroot); + evlog->runchroot = strdup(*cur + sizeof("chroot=") - 1); + if (evlog->runchroot == NULL) + goto oom; + continue; + } + break; + case 'i': + if (strncmp(*cur, "ignore_iolog_errors=", sizeof("ignore_iolog_errors=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("ignore_iolog_errors=") - 1) == true) + details->ignore_log_errors = true; + continue; + } + if (strncmp(*cur, "iolog_path=", sizeof("iolog_path=") - 1) == 0) { + free(evlog->iolog_path); + evlog->iolog_path = strdup(*cur + sizeof("iolog_path=") - 1); + if (evlog->iolog_path == NULL) + goto oom; + evlog->iolog_file = sudo_basename(evlog->iolog_path); + continue; + } + if (strncmp(*cur, "iolog_stdin=", sizeof("iolog_stdin=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("iolog_stdin=") - 1) == true) + iolog_files[IOFD_STDIN].enabled = true; + continue; + } + if (strncmp(*cur, "iolog_stdout=", sizeof("iolog_stdout=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("iolog_stdout=") - 1) == true) + iolog_files[IOFD_STDOUT].enabled = true; + continue; + } + if (strncmp(*cur, "iolog_stderr=", sizeof("iolog_stderr=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("iolog_stderr=") - 1) == true) + iolog_files[IOFD_STDERR].enabled = true; + continue; + } + if (strncmp(*cur, "iolog_ttyin=", sizeof("iolog_ttyin=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("iolog_ttyin=") - 1) == true) + iolog_files[IOFD_TTYIN].enabled = true; + continue; + } + if (strncmp(*cur, "iolog_ttyout=", sizeof("iolog_ttyout=") - 1) == 0) { + if (sudo_strtobool(*cur + sizeof("iolog_ttyout=") - 1) == true) + iolog_files[IOFD_TTYOUT].enabled = true; + continue; + } + if (strncmp(*cur, "iolog_compress=", sizeof("iolog_compress=") - 1) == 0) { + int val = sudo_strtobool(*cur + sizeof("iolog_compress=") - 1); + if (val != -1) { + iolog_set_compress(val); + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } + if (strncmp(*cur, "iolog_flush=", sizeof("iolog_flush=") - 1) == 0) { + int val = sudo_strtobool(*cur + sizeof("iolog_flush=") - 1); + if (val != -1) { + iolog_set_flush(val); + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } + if (strncmp(*cur, "iolog_mode=", sizeof("iolog_mode=") - 1) == 0) { + mode_t mode = sudo_strtomode(*cur + sizeof("iolog_mode=") - 1, &errstr); + if (errstr == NULL) { + iolog_set_mode(mode); + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } + if (strncmp(*cur, "iolog_group=", sizeof("iolog_group=") - 1) == 0) { + gr = sudo_getgrnam(*cur + sizeof("iolog_group=") - 1); + if (gr == NULL) { + sudo_debug_printf(SUDO_DEBUG_WARN, "%s: unknown group %s", + __func__, *cur + sizeof("iolog_group=") - 1); + } else { + iolog_set_gid(gr->gr_gid); + sudo_gr_delref(gr); + } + continue; + } + if (strncmp(*cur, "iolog_user=", sizeof("iolog_user=") - 1) == 0) { + pw = sudo_getpwnam(*cur + sizeof("iolog_user=") - 1); + if (pw == NULL) { + sudo_debug_printf(SUDO_DEBUG_WARN, "%s: unknown user %s", + __func__, *cur + sizeof("iolog_user=") - 1); + } else { + iolog_set_owner(pw->pw_uid, pw->pw_gid); + sudo_pw_delref(pw); + } + continue; + } + break; + case 'l': + if (strncmp(*cur, "log_passwords=", sizeof("log_passwords=") - 1) == 0) { + int val = sudo_strtobool(*cur + sizeof("log_passwords=") - 1); + if (val != -1) { + log_passwords = val; + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } + if (strncmp(*cur, "log_servers=", sizeof("log_servers=") - 1) == 0) { + details->log_servers = + deserialize_stringlist(*cur + sizeof("log_servers=") - 1); + if (!details->log_servers) + goto oom; + continue; + } + if (strncmp(*cur, "log_server_timeout=", sizeof("log_server_timeout=") - 1) == 0) { + details->server_timeout.tv_sec = + sudo_strtonum(*cur + sizeof("log_server_timeout=") - 1, 1, + TIME_T_MAX, NULL); + continue; + } + if (strncmp(*cur, "log_server_keepalive=", sizeof("log_server_keepalive=") - 1) == 0) { + int val = sudo_strtobool(*cur + sizeof("log_server_keepalive=") - 1); + if (val != -1) { + details->keepalive = val; + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } +#if defined(HAVE_OPENSSL) + if (strncmp(*cur, "log_server_cabundle=", sizeof("log_server_cabundle=") - 1) == 0) { + free(details->ca_bundle); + details->ca_bundle = strdup(*cur + sizeof("log_server_cabundle=") - 1); + if (details->ca_bundle == NULL) + goto oom; + continue; + } + if (strncmp(*cur, "log_server_peer_cert=", sizeof("log_server_peer_cert=") - 1) == 0) { + free(details->cert_file); + details->cert_file = strdup(*cur + sizeof("log_server_peer_cert=") - 1); + if (details->cert_file == NULL) + goto oom; + continue; + } + if (strncmp(*cur, "log_server_peer_key=", sizeof("log_server_peer_key=") - 1) == 0) { + free(details->key_file); + details->key_file = strdup(*cur + sizeof("log_server_peer_key=") - 1); + if (details->key_file == NULL) + goto oom; + continue; + } + if (strncmp(*cur, "log_server_verify=", sizeof("log_server_verify=") - 1) == 0) { + int val = sudo_strtobool(*cur + sizeof("log_server_verify=") - 1); + if (val != -1) { + details->verify_server = val; + } else { + sudo_debug_printf(SUDO_DEBUG_WARN, + "%s: unable to parse %s", __func__, *cur); + } + continue; + } +#endif /* HAVE_OPENSSL */ + break; + case 'm': + if (strncmp(*cur, "maxseq=", sizeof("maxseq=") - 1) == 0) { + union sudo_defs_val sd_un; + sd_un.str = *cur + sizeof("maxseq=") - 1; + cb_maxseq("policy", -1, -1, &sd_un, true); + continue; + } + break; + case 'p': + if (strncmp(*cur, "passprompt_regex=", sizeof("passprompt_regex=") - 1) == 0) { + iolog_pwfilt_free(passprompt_regex_handle); + passprompt_regex_handle = + set_passprompt_regex(*cur + sizeof("passprompt_regex=") - 1); + if (passprompt_regex_handle == NULL) + debug_return_int(-1); + } + break; + case 'r': + if (strncmp(*cur, "runas_gid=", sizeof("runas_gid=") - 1) == 0) { + runas_gid_str = *cur + sizeof("runas_gid=") - 1; + continue; + } + if (strncmp(*cur, "runas_egid=", sizeof("runas_egid=") - 1) == 0) { + runas_egid_str = *cur + sizeof("runas_egid=") - 1; + continue; + } + if (strncmp(*cur, "runas_uid=", sizeof("runas_uid=") - 1) == 0) { + runas_uid_str = *cur + sizeof("runas_uid=") - 1; + continue; + } + if (strncmp(*cur, "runas_euid=", sizeof("runas_euid=") - 1) == 0) { + runas_euid_str = *cur + sizeof("runas_euid=") - 1; + continue; + } + if (strncmp(*cur, "runcwd=", sizeof("runcwd=") - 1) == 0) { + free(evlog->runcwd); + evlog->runcwd = strdup(*cur + sizeof("runcwd=") - 1); + if (evlog->runcwd == NULL) + goto oom; + continue; + } + break; + } + } + + if (argv != NULL) { + evlog->argv = copy_vector_shallow(argv); + if (evlog->argv == NULL) + goto oom; + } + if (user_env != NULL) { + evlog->envp = copy_vector_shallow(user_env); + if (evlog->envp == NULL) + goto oom; + } + + /* + * Lookup runas user and group, preferring effective over real uid/gid. + */ + if (runas_euid_str != NULL) + runas_uid_str = runas_euid_str; + if (runas_uid_str != NULL) { + id = sudo_strtoid(runas_uid_str, &errstr); + if (errstr != NULL) + sudo_warnx("runas uid %s: %s", runas_uid_str, U_(errstr)); + else + evlog->runuid = (uid_t)id; + } + if (runas_egid_str != NULL) + runas_gid_str = runas_egid_str; + if (runas_gid_str != NULL) { + id = sudo_strtoid(runas_gid_str, &errstr); + if (errstr != NULL) + sudo_warnx("runas gid %s: %s", runas_gid_str, U_(errstr)); + else + evlog->rungid = (gid_t)id; + } + + pw = sudo_getpwuid(evlog->runuid); + if (pw != NULL) { + gid_t pw_gid = pw->pw_gid; + free(evlog->runuser); + evlog->runuser = strdup(pw->pw_name); + sudo_pw_delref(pw); + if (evlog->runuser == NULL) + goto oom; + if (evlog->rungid != pw_gid) { + gr = sudo_getgrgid(evlog->rungid); + if (gr != NULL) { + free(evlog->rungroup); + evlog->rungroup = strdup(gr->gr_name); + sudo_gr_delref(gr); + if (evlog->rungroup == NULL) + goto oom; + } else { + idbuf[0] = '#'; + strlcpy(&idbuf[1], runas_gid_str, sizeof(idbuf) - 1); + free(evlog->rungroup); + evlog->rungroup = strdup(idbuf); + if (evlog->rungroup == NULL) + goto oom; + } + } + } else { + idbuf[0] = '#'; + strlcpy(&idbuf[1], runas_uid_str, sizeof(idbuf) - 1); + free(evlog->runuser); + evlog->runuser = strdup(idbuf); + if (evlog->runuser == NULL) + goto oom; + } + + debug_return_int( + iolog_files[IOFD_STDIN].enabled || iolog_files[IOFD_STDOUT].enabled || + iolog_files[IOFD_STDERR].enabled || iolog_files[IOFD_TTYIN].enabled || + iolog_files[IOFD_TTYOUT].enabled); +oom: + sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory")); + debug_return_int(-1); +} + +static int +sudoers_io_open_local(struct timespec *now) +{ + struct eventlog *evlog = iolog_details.evlog; + int i, ret = -1; + debug_decl(sudoers_io_open_local, SUDOERS_DEBUG_PLUGIN); + + /* If no I/O log path defined we need to figure it out ourselves. */ + if (evlog->iolog_path == NULL) { + int len; + + /* Get next session ID and convert it into a path. */ + if (!iolog_nextid(_PATH_SUDO_IO_LOGDIR, evlog->sessid)) { + log_warning(SLOG_SEND_MAIL, N_("unable to update sequence file")); + warned = true; + goto done; + } + len = asprintf(&evlog->iolog_path, "%s/%c%c/%c%c/%c%c", + _PATH_SUDO_IO_LOGDIR, + evlog->sessid[0], evlog->sessid[1], evlog->sessid[2], + evlog->sessid[3], evlog->sessid[4], evlog->sessid[5]); + if (len == -1) { + sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory")); + goto done; + } + } + + /* + * Create I/O log path along with any intermediate subdirs. + * Calls mkdtemp() if iolog_path ends in XXXXXX. + */ + if (!iolog_mkpath(evlog->iolog_path)) { + log_warning(SLOG_SEND_MAIL, "%s", evlog->iolog_path); + warned = true; + goto done; + } + + iolog_dir_fd = iolog_openat(AT_FDCWD, evlog->iolog_path, O_RDONLY); + if (iolog_dir_fd == -1) { + log_warning(SLOG_SEND_MAIL, "%s", evlog->iolog_path); + warned = true; + goto done; + } + + /* Write log file with user and command details. */ + if (!iolog_write_info_file(iolog_dir_fd, iolog_details.evlog)) { + log_warningx(SLOG_SEND_MAIL, + N_("unable to write to I/O log file: %s"), strerror(errno)); + warned = true; + goto done; + } + + /* Create the timing and I/O log files. */ + for (i = 0; i < IOFD_MAX; i++) { + if (!iolog_open(&iolog_files[i], iolog_dir_fd, i, "w")) { + log_warning(SLOG_SEND_MAIL, N_("unable to create %s/%s"), + evlog->iolog_path, iolog_fd_to_name(i)); + warned = true; + goto done; + } + } + + ret = true; + +done: + debug_return_int(ret); +} + +#ifdef SUDOERS_LOG_CLIENT +static int +sudoers_io_open_remote(struct timespec *now) +{ + debug_decl(sudoers_io_open_remote, SUDOERS_DEBUG_PLUGIN); + + /* Open connection to log server, send hello and accept messages. */ + client_closure = log_server_open(&iolog_details, now, true, SEND_ACCEPT, + NULL); + if (client_closure != NULL) + debug_return_int(1); + + debug_return_int(-1); +} +#endif /* SUDOERS_LOG_CLIENT */ + +static int +sudoers_io_open(unsigned int version, sudo_conv_t conversation, + sudo_printf_t plugin_printf, char * const settings[], + char * const user_info[], char * const command_info[], + int argc, char * const argv[], char * const user_env[], char * const args[], + const char **errstr) +{ + struct sudo_conf_debug_file_list debug_files = TAILQ_HEAD_INITIALIZER(debug_files); + char * const *cur; + const char *cp, *plugin_path = NULL; + int ret = -1; + debug_decl(sudoers_io_open, SUDOERS_DEBUG_PLUGIN); + + sudo_conv = conversation; + sudo_printf = plugin_printf; + if (sudoers_io.event_alloc != NULL) + plugin_event_alloc = sudoers_io.event_alloc; + + bindtextdomain("sudoers", LOCALEDIR); + + /* Initialize the debug subsystem. */ + for (cur = settings; (cp = *cur) != NULL; cur++) { + if (strncmp(cp, "debug_flags=", sizeof("debug_flags=") - 1) == 0) { + cp += sizeof("debug_flags=") - 1; + if (!sudoers_debug_parse_flags(&debug_files, cp)) + debug_return_int(-1); + continue; + } + if (strncmp(cp, "plugin_path=", sizeof("plugin_path=") - 1) == 0) { + plugin_path = cp + sizeof("plugin_path=") - 1; + continue; + } + } + + if (!sudoers_debug_register(plugin_path, &debug_files)) + goto done; + + /* If we have no command (because -V was specified) just return. */ + if (argc == 0) + debug_return_int(true); + + /* + * Pull iolog settings out of command_info. + */ + ret = iolog_deserialize_info(&iolog_details, user_info, command_info, + argv, user_env); + if (ret != true) + goto done; + + /* Initialize io_operations. */ + sudoers_io_setops(); + + if (sudo_gettime_awake(&last_time) == -1) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_ERRNO, + "%s: unable to get time of day", __func__); + goto done; + } + + /* + * Create local I/O log file or connect to remote log server. + */ + if ((ret = io_operations.open(&last_time)) != true) + goto done; + + /* + * Clear I/O log function pointers for disabled log functions. + */ + if (!iolog_files[IOFD_STDIN].enabled) + sudoers_io.log_stdin = NULL; + if (!iolog_files[IOFD_STDOUT].enabled) + sudoers_io.log_stdout = NULL; + if (!iolog_files[IOFD_STDERR].enabled) + sudoers_io.log_stderr = NULL; + if (!iolog_files[IOFD_TTYIN].enabled) + sudoers_io.log_ttyin = NULL; + if (!iolog_files[IOFD_TTYOUT].enabled) + sudoers_io.log_ttyout = NULL; + +done: + if (ret != true) { + if (iolog_dir_fd != -1) { + close(iolog_dir_fd); + iolog_dir_fd = -1; + } + free_iolog_details(); + sudo_freepwcache(); + sudo_freegrcache(); + } + + /* Ignore errors if they occur if the policy says so. */ + if (ret == -1 && iolog_details.ignore_log_errors) + ret = 0; + + debug_return_int(ret); +} + +static void +sudoers_io_close_local(int exit_status, int error, const char **errstr) +{ + int i; + debug_decl(sudoers_io_close_local, SUDOERS_DEBUG_PLUGIN); + + /* Close the files. */ + for (i = 0; i < IOFD_MAX; i++) { + if (iolog_files[i].fd.v == NULL) + continue; + iolog_close(&iolog_files[i], errstr); + } + + /* Clear write bits from I/O timing file to indicate completion. */ + if (iolog_dir_fd != -1) { + struct stat sb; + if (fstatat(iolog_dir_fd, "timing", &sb, 0) != -1) { + CLR(sb.st_mode, S_IWUSR|S_IWGRP|S_IWOTH); + if (fchmodat(iolog_dir_fd, "timing", sb.st_mode, 0) == -1) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_ERRNO, + "%s: unable to fchmodat timing file", __func__); + } + } + close(iolog_dir_fd); + iolog_dir_fd = -1; + } + + debug_return; +} + +#ifdef SUDOERS_LOG_CLIENT +static void +sudoers_io_close_remote(int exit_status, int error, const char **errstr) +{ + debug_decl(sudoers_io_close_remote, SUDOERS_DEBUG_PLUGIN); + + log_server_close(client_closure, exit_status, error); + client_closure = NULL; + + debug_return; +} +#endif + +static void +sudoers_io_close(int exit_status, int error) +{ + const char *errstr = NULL; + debug_decl(sudoers_io_close, SUDOERS_DEBUG_PLUGIN); + + if (io_operations.close != NULL) + io_operations.close(exit_status, error, &errstr); + + if (errstr != NULL && !warned) { + /* Only warn about I/O log file errors once. */ + log_warningx(SLOG_SEND_MAIL, + N_("unable to write to I/O log file: %s"), errstr); + warned = true; + } + + free_iolog_details(); + sudo_freepwcache(); + sudo_freegrcache(); + iolog_pwfilt_free(passprompt_regex_handle); + passprompt_regex_handle = NULL; + + /* sudoers_debug_deregister() calls sudo_debug_exit() for us. */ + sudoers_debug_deregister(); +} + +static int +sudoers_io_version(int verbose) +{ + debug_decl(sudoers_io_version, SUDOERS_DEBUG_PLUGIN); + + sudo_printf(SUDO_CONV_INFO_MSG, "Sudoers I/O plugin version %s\n", + PACKAGE_VERSION); + + debug_return_int(true); +} + +/* + * Write an I/O log entry to the local file system. + * Returns 1 on success and -1 on error. + * Fills in errstr on error. + */ +static int +sudoers_io_log_local(int event, const char *buf, unsigned int len, + struct timespec *delay, const char **errstr) +{ + struct iolog_file *iol; + char tbuf[1024]; + char *newbuf = NULL; + int ret = -1; + debug_decl(sudoers_io_log_local, SUDOERS_DEBUG_PLUGIN); + + if (event < 0 || event >= IOFD_MAX) { + *errstr = NULL; + sudo_warnx(U_("unexpected I/O event %d"), event); + debug_return_int(-1); + } + iol = &iolog_files[event]; + if (!iol->enabled) { + *errstr = NULL; + sudo_warnx(U_("%s: internal error, I/O log file for event %d not open"), + __func__, event); + debug_return_int(-1); + } + + if (!log_passwords && passprompt_regex_handle != NULL) { + if (!iolog_pwfilt_run(passprompt_regex_handle, event, buf, len, &newbuf)) + debug_return_int(-1); + } + + /* Write I/O log file entry. */ + if (iolog_write(iol, newbuf ? newbuf : buf, len, errstr) == -1) + goto done; + + /* Write timing file entry. */ + len = (unsigned int)snprintf(tbuf, sizeof(tbuf), "%d %lld.%09ld %u\n", + event, (long long)delay->tv_sec, delay->tv_nsec, len); + if (len >= sizeof(tbuf)) { + /* Not actually possible due to the size of tbuf[]. */ + *errstr = strerror(EOVERFLOW); + goto done; + } + if (iolog_write(&iolog_files[IOFD_TIMING], tbuf, len, errstr) == -1) + goto done; + + /* Success. */ + ret = 1; + +done: + free(newbuf); + debug_return_int(ret); +} + +#ifdef SUDOERS_LOG_CLIENT +/* + * Schedule an I/O log entry to be written to the log server. + * Returns 1 on success and -1 on error. + * Fills in errstr on error. + */ +static int +sudoers_io_log_remote(int event, const char *buf, unsigned int len, + struct timespec *delay, const char **errstr) +{ + int type, ret = -1; + debug_decl(sudoers_io_log_remote, SUDOERS_DEBUG_PLUGIN); + + if (client_closure->disabled) + debug_return_int(1); + + /* Track elapsed time for comparison with commit points. */ + sudo_timespecadd(delay, &client_closure->elapsed, &client_closure->elapsed); + + switch (event) { + case IO_EVENT_STDIN: + type = CLIENT_MESSAGE__TYPE_STDIN_BUF; + break; + case IO_EVENT_STDOUT: + type = CLIENT_MESSAGE__TYPE_STDOUT_BUF; + break; + case IO_EVENT_STDERR: + type = CLIENT_MESSAGE__TYPE_STDERR_BUF; + break; + case IO_EVENT_TTYIN: + type = CLIENT_MESSAGE__TYPE_TTYIN_BUF; + break; + case IO_EVENT_TTYOUT: + type = CLIENT_MESSAGE__TYPE_TTYOUT_BUF; + break; + default: + sudo_warnx(U_("unexpected I/O event %d"), event); + goto done; + } + if (fmt_io_buf(client_closure, type, buf, len, delay)) { + ret = client_closure->write_ev->add(client_closure->write_ev, + &iolog_details.server_timeout); + if (ret == -1) + sudo_warn("%s", U_("unable to add event to queue")); + } + +done: + debug_return_int(ret); +} +#endif /* SUDOERS_LOG_CLIENT */ + +/* + * Generic I/O logging function. Called by the I/O logging entry points. + * Returns 1 on success and -1 on error. + */ +static int +sudoers_io_log(const char *buf, unsigned int len, int event, const char **errstr) +{ + struct timespec now, delay; + const char *ioerror = NULL; + int ret = -1; + debug_decl(sudoers_io_log, SUDOERS_DEBUG_PLUGIN); + + if (sudo_gettime_awake(&now) == -1) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_ERRNO, + "%s: unable to get time of day", __func__); + ioerror = N_("unable to read the clock"); + goto bad; + } + sudo_timespecsub(&now, &last_time, &delay); + + ret = io_operations.log(event, buf, len, &delay, &ioerror); + + last_time.tv_sec = now.tv_sec; + last_time.tv_nsec = now.tv_nsec; + +bad: + if (ret == -1) { + if (ioerror != NULL) { + char *cp; + + if (asprintf(&cp, N_("unable to write to I/O log file: %s"), + ioerror) != -1) { + *errstr = cp; + } + if (!warned) { + /* Only warn about I/O log file errors once. */ + log_warningx(SLOG_SEND_MAIL, + N_("unable to write to I/O log file: %s"), ioerror); + warned = true; + } + } + + /* Ignore errors if they occur if the policy says so. */ + if (iolog_details.ignore_log_errors) + ret = 1; + } + + debug_return_int(ret); +} + +static int +sudoers_io_log_stdin(const char *buf, unsigned int len, const char **errstr) +{ + return sudoers_io_log(buf, len, IO_EVENT_STDIN, errstr); +} + +static int +sudoers_io_log_stdout(const char *buf, unsigned int len, const char **errstr) +{ + return sudoers_io_log(buf, len, IO_EVENT_STDOUT, errstr); +} + +static int +sudoers_io_log_stderr(const char *buf, unsigned int len, const char **errstr) +{ + return sudoers_io_log(buf, len, IO_EVENT_STDERR, errstr); +} + +static int +sudoers_io_log_ttyin(const char *buf, unsigned int len, const char **errstr) +{ + return sudoers_io_log(buf, len, IO_EVENT_TTYIN, errstr); +} + +static int +sudoers_io_log_ttyout(const char *buf, unsigned int len, const char **errstr) +{ + return sudoers_io_log(buf, len, IO_EVENT_TTYOUT, errstr); +} + +static int +sudoers_io_change_winsize_local(unsigned int lines, unsigned int cols, + struct timespec *delay, const char **errstr) +{ + char tbuf[1024]; + int len, ret = -1; + debug_decl(sudoers_io_change_winsize_local, SUDOERS_DEBUG_PLUGIN); + + /* Write window change event to the timing file. */ + len = snprintf(tbuf, sizeof(tbuf), "%d %lld.%09ld %u %u\n", + IO_EVENT_WINSIZE, (long long)delay->tv_sec, delay->tv_nsec, + lines, cols); + if (len < 0 || len >= ssizeof(tbuf)) { + /* Not actually possible due to the size of tbuf[]. */ + *errstr = strerror(EOVERFLOW); + goto done; + } + if (iolog_write(&iolog_files[IOFD_TIMING], tbuf, len, errstr) == -1) + goto done; + + /* Success. */ + ret = 1; + +done: + debug_return_int(ret); +} + +#ifdef SUDOERS_LOG_CLIENT +static int +sudoers_io_change_winsize_remote(unsigned int lines, unsigned int cols, + struct timespec *delay, const char **errstr) +{ + int ret = -1; + debug_decl(sudoers_io_change_winsize_remote, SUDOERS_DEBUG_PLUGIN); + + if (client_closure->disabled) + debug_return_int(1); + + /* Track elapsed time for comparison with commit points. */ + sudo_timespecadd(delay, &client_closure->elapsed, &client_closure->elapsed); + + if (fmt_winsize(client_closure, lines, cols, delay)) { + ret = client_closure->write_ev->add(client_closure->write_ev, + &iolog_details.server_timeout); + if (ret == -1) + sudo_warn("%s", U_("unable to add event to queue")); + } + + debug_return_int(ret); +} +#endif /* SUDOERS_LOG_CLIENT */ + +static int +sudoers_io_change_winsize(unsigned int lines, unsigned int cols, const char **errstr) +{ + struct timespec now, delay; + const char *ioerror = NULL; + int ret = -1; + debug_decl(sudoers_io_change_winsize, SUDOERS_DEBUG_PLUGIN); + + if (sudo_gettime_awake(&now) == -1) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_ERRNO, + "%s: unable to get time of day", __func__); + ioerror = N_("unable to read the clock"); + goto bad; + } + sudo_timespecsub(&now, &last_time, &delay); + + ret = io_operations.change_winsize(lines, cols, &delay, &ioerror); + + last_time.tv_sec = now.tv_sec; + last_time.tv_nsec = now.tv_nsec; + +bad: + if (ret == -1) { + if (ioerror != NULL && !warned) { + char *cp; + + if (asprintf(&cp, N_("unable to write to I/O log file: %s"), + ioerror) != -1) { + *errstr = cp; + } + if (!warned) { + /* Only warn about I/O log file errors once. */ + log_warningx(SLOG_SEND_MAIL, + N_("unable to write to I/O log file: %s"), ioerror); + warned = true; + } + } + + /* Ignore errors if they occur if the policy says so. */ + if (iolog_details.ignore_log_errors) + ret = 1; + } + + debug_return_int(ret); +} + +static int +sudoers_io_suspend_local(const char *signame, struct timespec *delay, + const char **errstr) +{ + unsigned int len; + char tbuf[1024]; + int ret = -1; + debug_decl(sudoers_io_suspend_local, SUDOERS_DEBUG_PLUGIN); + + /* Write suspend event to the timing file. */ + len = (unsigned int)snprintf(tbuf, sizeof(tbuf), "%d %lld.%09ld %s\n", + IO_EVENT_SUSPEND, (long long)delay->tv_sec, delay->tv_nsec, signame); + if (len >= sizeof(tbuf)) { + /* Not actually possible due to the size of tbuf[]. */ + *errstr = strerror(EOVERFLOW); + goto done; + } + if (iolog_write(&iolog_files[IOFD_TIMING], tbuf, len, errstr) == -1) + goto done; + + /* Success. */ + ret = 1; + +done: + debug_return_int(ret); +} + +#ifdef SUDOERS_LOG_CLIENT +static int +sudoers_io_suspend_remote(const char *signame, struct timespec *delay, + const char **errstr) +{ + int ret = -1; + debug_decl(sudoers_io_suspend_remote, SUDOERS_DEBUG_PLUGIN); + + if (client_closure->disabled) + debug_return_int(1); + + /* Track elapsed time for comparison with commit points. */ + sudo_timespecadd(delay, &client_closure->elapsed, &client_closure->elapsed); + + if (fmt_suspend(client_closure, signame, delay)) { + ret = client_closure->write_ev->add(client_closure->write_ev, + &iolog_details.server_timeout); + if (ret == -1) + sudo_warn("%s", U_("unable to add event to queue")); + } + + debug_return_int(ret); +} +#endif /* SUDOERS_LOG_CLIENT */ + +static int +sudoers_io_suspend(int signo, const char **errstr) +{ + struct timespec now, delay; + char signame[SIG2STR_MAX]; + const char *ioerror = NULL; + int ret = -1; + debug_decl(sudoers_io_suspend, SUDOERS_DEBUG_PLUGIN); + + if (signo <= 0 || sig2str(signo, signame) == -1) { + sudo_warnx(U_("%s: internal error, invalid signal %d"), + __func__, signo); + debug_return_int(-1); + } + + if (sudo_gettime_awake(&now) == -1) { + sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_ERRNO, + "%s: unable to get time of day", __func__); + ioerror = N_("unable to read the clock"); + goto bad; + } + sudo_timespecsub(&now, &last_time, &delay); + + /* Write suspend event to the timing file. */ + ret = io_operations.suspend(signame, &delay, &ioerror); + + last_time.tv_sec = now.tv_sec; + last_time.tv_nsec = now.tv_nsec; + +bad: + if (ret == -1) { + if (ioerror != NULL && !warned) { + char *cp; + + if (asprintf(&cp, N_("unable to write to I/O log file: %s"), + ioerror) != -1) { + *errstr = cp; + } + if (!warned) { + /* Only warn about I/O log file errors once. */ + log_warningx(SLOG_SEND_MAIL, + N_("unable to write to I/O log file: %s"), ioerror); + warned = true; + } + } + + /* Ignore errors if they occur if the policy says so. */ + if (iolog_details.ignore_log_errors) + ret = 1; + } + + debug_return_int(ret); +} + +/* + * Fill in the contents of io_operations, either local or remote. + */ +static void +sudoers_io_setops(void) +{ + debug_decl(sudoers_io_setops, SUDOERS_DEBUG_PLUGIN); + +#ifdef SUDOERS_LOG_CLIENT + if (plugin_event_alloc != NULL && iolog_details.log_servers != NULL) { + io_operations.open = sudoers_io_open_remote; + io_operations.close = sudoers_io_close_remote; + io_operations.log = sudoers_io_log_remote; + io_operations.change_winsize = sudoers_io_change_winsize_remote; + io_operations.suspend = sudoers_io_suspend_remote; + } else +#endif /* SUDOERS_LOG_CLIENT */ + { + io_operations.open = sudoers_io_open_local; + io_operations.close = sudoers_io_close_local; + io_operations.log = sudoers_io_log_local; + io_operations.change_winsize = sudoers_io_change_winsize_local; + io_operations.suspend = sudoers_io_suspend_local; + } + + debug_return; +} + +sudo_dso_public struct io_plugin sudoers_io = { + SUDO_IO_PLUGIN, + SUDO_API_VERSION, + sudoers_io_open, + sudoers_io_close, + sudoers_io_version, + sudoers_io_log_ttyin, + sudoers_io_log_ttyout, + sudoers_io_log_stdin, + sudoers_io_log_stdout, + sudoers_io_log_stderr, + NULL, /* register_hooks */ + NULL, /* deregister_hooks */ + sudoers_io_change_winsize, + sudoers_io_suspend, + NULL /* event_alloc() filled in by sudo */ +}; |