version 1.1.1.3, 2012/10/09 09:29:52
|
version 1.1.1.5, 2014/06/15 16:12:55
|
Line 1
|
Line 1
|
/* |
/* |
* Copyright (c) 2009-2011 Todd C. Miller <Todd.Miller@courtesan.com> | * Copyright (c) 2009-2013 Todd C. Miller <Todd.Miller@courtesan.com> |
* |
* |
* Permission to use, copy, modify, and distribute this software for any |
* Permission to use, copy, modify, and distribute this software for any |
* purpose with or without fee is hereby granted, provided that the above |
* purpose with or without fee is hereby granted, provided that the above |
Line 17
|
Line 17
|
#include <config.h> |
#include <config.h> |
|
|
#include <sys/types.h> |
#include <sys/types.h> |
#include <sys/param.h> |
|
#include <sys/stat.h> |
#include <sys/stat.h> |
#include <stdio.h> |
#include <stdio.h> |
#ifdef STDC_HEADERS |
#ifdef STDC_HEADERS |
Line 37
|
Line 36
|
#ifdef HAVE_UNISTD_H |
#ifdef HAVE_UNISTD_H |
# include <unistd.h> |
# include <unistd.h> |
#endif /* HAVE_UNISTD_H */ |
#endif /* HAVE_UNISTD_H */ |
#ifdef HAVE_DLOPEN |
|
# include <dlfcn.h> |
|
#else |
|
# include "compat/dlfcn.h" |
|
#endif |
|
#include <errno.h> |
#include <errno.h> |
|
|
#include "sudo.h" |
#include "sudo.h" |
#include "sudo_plugin.h" |
#include "sudo_plugin.h" |
#include "sudo_plugin_int.h" |
#include "sudo_plugin_int.h" |
#include "sudo_conf.h" |
#include "sudo_conf.h" |
|
#include "sudo_dso.h" |
#include "sudo_debug.h" |
#include "sudo_debug.h" |
|
|
#ifndef RTLD_GLOBAL | /* We always use the same name for the sudoers plugin, regardless of the OS */ |
# define RTLD_GLOBAL 0 | #define SUDOERS_PLUGIN "sudoers.so" |
#endif | |
|
|
/* | #ifdef _PATH_SUDO_PLUGIN_DIR |
* Load the plugin specified by "info". | static int |
*/ | sudo_stat_plugin(struct plugin_info *info, char *fullpath, |
static bool | size_t pathsize, struct stat *sb) |
sudo_load_plugin(struct plugin_container *policy_plugin, | |
struct plugin_container_list *io_plugins, struct plugin_info *info) | |
{ |
{ |
struct plugin_container *container; | int status = -1; |
struct generic_plugin *plugin; | debug_decl(sudo_stat_plugin, SUDO_DEBUG_PLUGIN) |
struct stat sb; | |
void *handle; | |
char path[PATH_MAX]; | |
bool rval = false; | |
debug_decl(sudo_load_plugin, SUDO_DEBUG_PLUGIN) | |
|
|
if (info->path[0] == '/') { |
if (info->path[0] == '/') { |
if (strlcpy(path, info->path, sizeof(path)) >= sizeof(path)) { | if (strlcpy(fullpath, info->path, pathsize) >= pathsize) { |
warningx(_("%s: %s"), info->path, strerror(ENAMETOOLONG)); | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("%s: %s"), info->path, strerror(ENAMETOOLONG)); |
goto done; |
goto done; |
} |
} |
|
status = stat(fullpath, sb); |
} else { |
} else { |
if (snprintf(path, sizeof(path), "%s%s", _PATH_SUDO_PLUGIN_DIR, | int len; |
info->path) >= sizeof(path)) { | |
warningx(_("%s%s: %s"), _PATH_SUDO_PLUGIN_DIR, info->path, | #ifdef STATIC_SUDOERS_PLUGIN |
| /* Check static symbols. */ |
| if (strcmp(info->path, SUDOERS_PLUGIN) == 0) { |
| if (strlcpy(fullpath, info->path, pathsize) >= pathsize) { |
| warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("%s: %s"), info->path, strerror(ENAMETOOLONG)); |
| goto done; |
| } |
| /* Plugin is static, fake up struct stat. */ |
| memset(sb, 0, sizeof(*sb)); |
| sb->st_uid = ROOT_UID; |
| sb->st_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH; |
| status = 0; |
| goto done; |
| } |
| #endif /* STATIC_SUDOERS_PLUGIN */ |
| |
| len = snprintf(fullpath, pathsize, "%s%s", _PATH_SUDO_PLUGIN_DIR, |
| info->path); |
| if (len <= 0 || (size_t)len >= pathsize) { |
| warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("%s%s: %s"), _PATH_SUDO_PLUGIN_DIR, info->path, |
strerror(ENAMETOOLONG)); |
strerror(ENAMETOOLONG)); |
goto done; |
goto done; |
} |
} |
|
/* Try parent dir for compatibility with old plugindir default. */ |
|
if ((status = stat(fullpath, sb)) != 0) { |
|
char *cp = strrchr(fullpath, '/'); |
|
if (cp > fullpath + 4 && cp[-5] == '/' && cp[-4] == 's' && |
|
cp[-3] == 'u' && cp[-2] == 'd' && cp[-1] == 'o') { |
|
int serrno = errno; |
|
strlcpy(cp - 4, info->path, pathsize - (cp - 4 - fullpath)); |
|
if ((status = stat(fullpath, sb)) != 0) |
|
errno = serrno; |
|
} |
|
} |
|
# ifdef __hpux |
|
/* Try .sl instead of .so on HP-UX for backwards compatibility. */ |
|
if (status != 0) { |
|
size_t len = strlen(info->path); |
|
if (len >= 3 && info->path[len - 3] == '.' && |
|
info->path[len - 2] == 's' && info->path[len - 1] == 'o') { |
|
const char *sopath = info->path; |
|
char *slpath = estrdup(info->path); |
|
int serrno = errno; |
|
|
|
slpath[len - 1] = 'l'; |
|
info->path = slpath; |
|
status = sudo_stat_plugin(info, fullpath, pathsize, sb); |
|
if (status == 0) { |
|
efree((void *)sopath); |
|
} else { |
|
efree(slpath); |
|
info->path = sopath; |
|
errno = serrno; |
|
} |
|
} |
|
} |
|
# endif /* __hpux */ |
} |
} |
if (stat(path, &sb) != 0) { | done: |
warning("%s", path); | debug_return_int(status); |
| } |
| |
| static bool |
| sudo_check_plugin(struct plugin_info *info, char *fullpath, size_t pathsize) |
| { |
| struct stat sb; |
| int rval = false; |
| debug_decl(sudo_check_plugin, SUDO_DEBUG_PLUGIN) |
| |
| if (sudo_stat_plugin(info, fullpath, pathsize, &sb) != 0) { |
| warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warning("%s%s", _PATH_SUDO_PLUGIN_DIR, info->path); |
goto done; |
goto done; |
} |
} |
if (sb.st_uid != ROOT_UID) { |
if (sb.st_uid != ROOT_UID) { |
warningx(_("%s must be owned by uid %d"), path, ROOT_UID); | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("%s must be owned by uid %d"), fullpath, ROOT_UID); |
goto done; |
goto done; |
} |
} |
if ((sb.st_mode & (S_IWGRP|S_IWOTH)) != 0) { |
if ((sb.st_mode & (S_IWGRP|S_IWOTH)) != 0) { |
warningx(_("%s must be only be writable by owner"), path); | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("%s must be only be writable by owner"), fullpath); |
goto done; |
goto done; |
} |
} |
|
rval = true; |
|
|
|
done: |
|
debug_return_bool(rval); |
|
} |
|
#else |
|
static bool |
|
sudo_check_plugin(struct plugin_info *info, char *fullpath, size_t pathsize) |
|
{ |
|
debug_decl(sudo_check_plugin, SUDO_DEBUG_PLUGIN) |
|
(void)strlcpy(fullpath, info->path, pathsize); |
|
debug_return_bool(true); |
|
} |
|
#endif /* _PATH_SUDO_PLUGIN_DIR */ |
|
|
|
/* |
|
* Load the plugin specified by "info". |
|
*/ |
|
static bool |
|
sudo_load_plugin(struct plugin_container *policy_plugin, |
|
struct plugin_container_list *io_plugins, struct plugin_info *info) |
|
{ |
|
struct plugin_container *container; |
|
struct generic_plugin *plugin; |
|
char path[PATH_MAX]; |
|
bool rval = false; |
|
void *handle; |
|
debug_decl(sudo_load_plugin, SUDO_DEBUG_PLUGIN) |
|
|
|
/* Sanity check plugin and fill in path */ |
|
if (!sudo_check_plugin(info, path, sizeof(path))) |
|
goto done; |
|
|
/* Open plugin and map in symbol */ |
/* Open plugin and map in symbol */ |
handle = dlopen(path, RTLD_LAZY|RTLD_GLOBAL); | handle = sudo_dso_load(path, SUDO_DSO_LAZY|SUDO_DSO_GLOBAL); |
if (!handle) { |
if (!handle) { |
warningx(_("unable to dlopen %s: %s"), path, dlerror()); | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("unable to load %s: %s"), path, sudo_dso_strerror()); |
goto done; |
goto done; |
} |
} |
plugin = dlsym(handle, info->symbol_name); | plugin = sudo_dso_findsym(handle, info->symbol_name); |
if (!plugin) { |
if (!plugin) { |
warningx(_("%s: unable to find symbol %s"), path, | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
info->symbol_name); | _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("unable to find symbol `%s' in %s"), info->symbol_name, path); |
goto done; |
goto done; |
} |
} |
|
|
if (plugin->type != SUDO_POLICY_PLUGIN && plugin->type != SUDO_IO_PLUGIN) { |
if (plugin->type != SUDO_POLICY_PLUGIN && plugin->type != SUDO_IO_PLUGIN) { |
warningx(_("%s: unknown policy type %d"), path, plugin->type); | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
| _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
| warningx(U_("unknown policy type %d found in %s"), plugin->type, path); |
goto done; |
goto done; |
} |
} |
if (SUDO_API_VERSION_GET_MAJOR(plugin->version) != SUDO_API_VERSION_MAJOR) { |
if (SUDO_API_VERSION_GET_MAJOR(plugin->version) != SUDO_API_VERSION_MAJOR) { |
warningx(_("%s: incompatible policy major version %d, expected %d"), | warningx(U_("error in %s, line %d while loading plugin `%s'"), |
path, SUDO_API_VERSION_GET_MAJOR(plugin->version), | _PATH_SUDO_CONF, info->lineno, info->symbol_name); |
SUDO_API_VERSION_MAJOR); | warningx(U_("incompatible plugin major version %d (expected %d) found in %s"), |
| SUDO_API_VERSION_GET_MAJOR(plugin->version), |
| SUDO_API_VERSION_MAJOR, path); |
goto done; |
goto done; |
} |
} |
if (plugin->type == SUDO_POLICY_PLUGIN) { |
if (plugin->type == SUDO_POLICY_PLUGIN) { |
if (policy_plugin->handle) { |
if (policy_plugin->handle) { |
warningx(_("%s: only a single policy plugin may be loaded"), | /* Ignore duplicate entries. */ |
_PATH_SUDO_CONF); | if (strcmp(policy_plugin->name, info->symbol_name) != 0) { |
goto done; | warningx(U_("ignoring policy plugin `%s' in %s, line %d"), |
| info->symbol_name, _PATH_SUDO_CONF, info->lineno); |
| warningx(U_("only a single policy plugin may be specified")); |
| goto done; |
| } |
| warningx(U_("ignoring duplicate policy plugin `%s' in %s, line %d"), |
| info->symbol_name, _PATH_SUDO_CONF, info->lineno); |
| sudo_dso_unload(handle); |
| handle = NULL; |
} |
} |
policy_plugin->handle = handle; | if (handle != NULL) { |
policy_plugin->name = info->symbol_name; | policy_plugin->handle = handle; |
policy_plugin->options = info->options; | policy_plugin->name = info->symbol_name; |
policy_plugin->u.generic = plugin; | policy_plugin->options = info->options; |
| policy_plugin->u.generic = plugin; |
| } |
} else if (plugin->type == SUDO_IO_PLUGIN) { |
} else if (plugin->type == SUDO_IO_PLUGIN) { |
container = ecalloc(1, sizeof(*container)); | /* Check for duplicate entries. */ |
container->prev = container; | TAILQ_FOREACH(container, io_plugins, entries) { |
/* container->next = NULL; */ | if (strcmp(container->name, info->symbol_name) == 0) { |
container->handle = handle; | warningx(U_("ignoring duplicate I/O plugin `%s' in %s, line %d"), |
container->name = info->symbol_name; | info->symbol_name, _PATH_SUDO_CONF, info->lineno); |
container->options = info->options; | sudo_dso_unload(handle); |
container->u.generic = plugin; | handle = NULL; |
tq_append(io_plugins, container); | break; |
| } |
| } |
| if (handle != NULL) { |
| container = ecalloc(1, sizeof(*container)); |
| container->handle = handle; |
| container->name = info->symbol_name; |
| container->options = info->options; |
| container->u.generic = plugin; |
| TAILQ_INSERT_TAIL(io_plugins, container, entries); |
| } |
} |
} |
|
|
rval = true; |
rval = true; |
Line 159 sudo_load_plugins(struct plugin_container *policy_plug
|
Line 282 sudo_load_plugins(struct plugin_container *policy_plug
|
|
|
/* Walk the plugin list from sudo.conf, if any. */ |
/* Walk the plugin list from sudo.conf, if any. */ |
plugins = sudo_conf_plugins(); |
plugins = sudo_conf_plugins(); |
tq_foreach_fwd(plugins, info) { | TAILQ_FOREACH(info, plugins, entries) { |
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
if (!rval) |
if (!rval) |
goto done; |
goto done; |
Line 175 sudo_load_plugins(struct plugin_container *policy_plug
|
Line 298 sudo_load_plugins(struct plugin_container *policy_plug
|
info->symbol_name = "sudoers_policy"; |
info->symbol_name = "sudoers_policy"; |
info->path = SUDOERS_PLUGIN; |
info->path = SUDOERS_PLUGIN; |
/* info->options = NULL; */ |
/* info->options = NULL; */ |
info->prev = info; |
|
/* info->next = NULL; */ |
|
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
efree(info); |
efree(info); |
if (!rval) |
if (!rval) |
goto done; |
goto done; |
|
|
/* Default I/O plugin */ |
/* Default I/O plugin */ |
if (tq_empty(io_plugins)) { | if (TAILQ_EMPTY(io_plugins)) { |
info = ecalloc(1, sizeof(*info)); |
info = ecalloc(1, sizeof(*info)); |
info->symbol_name = "sudoers_io"; |
info->symbol_name = "sudoers_io"; |
info->path = SUDOERS_PLUGIN; |
info->path = SUDOERS_PLUGIN; |
/* info->options = NULL; */ |
/* info->options = NULL; */ |
info->prev = info; |
|
/* info->next = NULL; */ |
|
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
rval = sudo_load_plugin(policy_plugin, io_plugins, info); |
efree(info); |
efree(info); |
if (!rval) |
if (!rval) |
Line 197 sudo_load_plugins(struct plugin_container *policy_plug
|
Line 316 sudo_load_plugins(struct plugin_container *policy_plug
|
} |
} |
} |
} |
if (policy_plugin->u.policy->check_policy == NULL) { |
if (policy_plugin->u.policy->check_policy == NULL) { |
warningx(_("policy plugin %s does not include a check_policy method"), | warningx(U_("policy plugin %s does not include a check_policy method"), |
policy_plugin->name); |
policy_plugin->name); |
rval = false; |
rval = false; |
goto done; |
goto done; |
Line 208 sudo_load_plugins(struct plugin_container *policy_plug
|
Line 327 sudo_load_plugins(struct plugin_container *policy_plug
|
if (policy_plugin->u.policy->register_hooks != NULL) |
if (policy_plugin->u.policy->register_hooks != NULL) |
policy_plugin->u.policy->register_hooks(SUDO_HOOK_VERSION, register_hook); |
policy_plugin->u.policy->register_hooks(SUDO_HOOK_VERSION, register_hook); |
} |
} |
tq_foreach_fwd(io_plugins, container) { | TAILQ_FOREACH(container, io_plugins, entries) { |
if (container->u.io->version >= SUDO_API_MKVERSION(1, 2)) { |
if (container->u.io->version >= SUDO_API_MKVERSION(1, 2)) { |
if (container->u.io->register_hooks != NULL) |
if (container->u.io->register_hooks != NULL) |
container->u.io->register_hooks(SUDO_HOOK_VERSION, register_hook); |
container->u.io->register_hooks(SUDO_HOOK_VERSION, register_hook); |