<sopwith@redhat.com> (see copyright below for full details)
*/
-#define UID_WRAPPER_NOT_REPLACE
-
#include "pam_winbind.h"
+enum pam_winbind_request_type
+{
+ PAM_WINBIND_AUTHENTICATE,
+ PAM_WINBIND_SETCRED,
+ PAM_WINBIND_ACCT_MGMT,
+ PAM_WINBIND_OPEN_SESSION,
+ PAM_WINBIND_CLOSE_SESSION,
+ PAM_WINBIND_CHAUTHTOK,
+ PAM_WINBIND_CLEANUP
+};
+
static int wbc_error_to_pam_error(wbcErr status)
{
switch (status) {
#define _PAM_LOG_FUNCTION_LEAVE(function, ctx, retval) \
do { \
_pam_log_debug(ctx, LOG_DEBUG, "[pamh: %p] LEAVE: " \
- function " returning %d (%s)", ctx->pamh, retval, \
+ function " returning %d (%s)", ctx ? ctx->pamh : NULL, retval, \
_pam_error_code_str(retval)); \
_pam_log_state(ctx); \
} while (0)
/* some syslogging */
+static void _pam_log_int(const pam_handle_t *pamh,
+ int err,
+ const char *format,
+ va_list args) PRINTF_ATTRIBUTE(3, 0);
#ifdef HAVE_PAM_VSYSLOG
static void _pam_log_int(const pam_handle_t *pamh,
const char *format,
va_list args)
{
- char *format2 = NULL;
+ char *base = NULL;
+ va_list args2;
const char *service;
+ int ret;
+
+ va_copy(args2, args);
pam_get_item(pamh, PAM_SERVICE, (const void **) &service);
- format2 = (char *)malloc(strlen(MODULE_NAME)+strlen(format)+strlen(service)+5);
- if (format2 == NULL) {
+ ret = vasprintf(&base, format, args);
+ if (ret == -1) {
/* what else todo ? */
- vsyslog(err, format, args);
+ vsyslog(err, format, args2);
+ va_end(args2);
return;
}
- sprintf(format2, "%s(%s): %s", MODULE_NAME, service, format);
- vsyslog(err, format2, args);
- SAFE_FREE(format2);
+ syslog(err, "%s(%s): %s", MODULE_NAME, service, base);
+ SAFE_FREE(base);
+ va_end(args2);
}
#endif /* HAVE_PAM_VSYSLOG */
{
va_list args;
- if (!_pam_log_is_debug_enabled(r->ctrl)) {
+ if (!r || !_pam_log_is_debug_enabled(r->ctrl)) {
return;
}
#define _PAM_LOG_STATE_ITEM_PASSWORD(ctx, item_type) \
_pam_log_state_datum(ctx, item_type, #item_type, \
_LOG_PASSWORD_AS_STRING)
+/*
+ * wrapper to preserve old behaviour of iniparser which ignored
+ * key values that had no value assigned like
+ * key =
+ * for a key like above newer iniparser will return a zero-length
+ * string, previously iniparser would return NULL
+ *
+ * JRA: For compatibility, tiniparser behaves like iniparser.
+ */
+static const char *tiniparser_getstring_nonempty(struct tiniparser_dictionary *d,
+ const char *key,
+ const char *def)
+{
+ const char *ret = tiniparser_getstring(d, key, def);
+ if (ret && strlen(ret) == 0) {
+ ret = NULL;
+ }
+ return ret;
+}
static void _pam_log_state(struct pwb_context *ctx)
{
- if (!_pam_log_is_debug_state_enabled(ctx->ctrl)) {
+ if (!ctx || !_pam_log_is_debug_state_enabled(ctx->ctrl)) {
return;
}
int flags,
int argc,
const char **argv,
- dictionary **result_d)
+ enum pam_winbind_request_type type,
+ struct tiniparser_dictionary **result_d)
{
int ctrl = 0;
const char *config_file = NULL;
int i;
const char **v;
- dictionary *d = NULL;
+ struct tiniparser_dictionary *d = NULL;
if (flags & PAM_SILENT) {
ctrl |= WINBIND_SILENT;
config_file = PAM_WINBIND_CONFIG_FILE;
}
- d = iniparser_load(discard_const_p(char, config_file));
+ d = tiniparser_load(config_file);
if (d == NULL) {
goto config_from_pam;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:debug"), false)) {
+ if (tiniparser_getboolean(d, "global:debug", false)) {
ctrl |= WINBIND_DEBUG_ARG;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:debug_state"), false)) {
+ if (tiniparser_getboolean(d, "global:debug_state", false)) {
ctrl |= WINBIND_DEBUG_STATE;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:cached_login"), false)) {
+ if (tiniparser_getboolean(d, "global:cached_login", false)) {
ctrl |= WINBIND_CACHED_LOGIN;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:krb5_auth"), false)) {
+ if (tiniparser_getboolean(d, "global:krb5_auth", false)) {
ctrl |= WINBIND_KRB5_AUTH;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:silent"), false)) {
+ if (tiniparser_getboolean(d, "global:silent", false)) {
ctrl |= WINBIND_SILENT;
}
- if (iniparser_getstring(d, discard_const_p(char, "global:krb5_ccache_type"), NULL) != NULL) {
+ if (tiniparser_getstring_nonempty(d, "global:krb5_ccache_type", NULL) != NULL) {
ctrl |= WINBIND_KRB5_CCACHE_TYPE;
}
- if ((iniparser_getstring(d, discard_const_p(char, "global:require-membership-of"), NULL)
+ if ((tiniparser_getstring_nonempty(d, "global:require-membership-of", NULL)
!= NULL) ||
- (iniparser_getstring(d, discard_const_p(char, "global:require_membership_of"), NULL)
+ (tiniparser_getstring_nonempty(d, "global:require_membership_of", NULL)
!= NULL)) {
ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:try_first_pass"), false)) {
+ if (tiniparser_getboolean(d, "global:try_first_pass", false)) {
ctrl |= WINBIND_TRY_FIRST_PASS_ARG;
}
- if (iniparser_getint(d, discard_const_p(char, "global:warn_pwd_expire"), 0)) {
+ if (tiniparser_getint(d, "global:warn_pwd_expire", 0)) {
ctrl |= WINBIND_WARN_PWD_EXPIRE;
}
- if (iniparser_getboolean(d, discard_const_p(char, "global:mkhomedir"), false)) {
+ if (tiniparser_getboolean(d, "global:mkhomedir", false)) {
ctrl |= WINBIND_MKHOMEDIR;
}
+ if (tiniparser_getboolean(d, "global:pwd_change_prompt", false)) {
+ ctrl |= WINBIND_PWD_CHANGE_PROMPT;
+ }
+
config_from_pam:
/* step through arguments */
for (i=argc,v=argv; i-- > 0; ++v) {
ctrl |= WINBIND_SILENT;
else if (!strcasecmp(*v, "use_authtok"))
ctrl |= WINBIND_USE_AUTHTOK_ARG;
+ else if (!strcasecmp(*v, "try_authtok"))
+ ctrl |= WINBIND_TRY_AUTHTOK_ARG;
else if (!strcasecmp(*v, "use_first_pass"))
ctrl |= WINBIND_USE_FIRST_PASS_ARG;
else if (!strcasecmp(*v, "try_first_pass"))
ctrl |= WINBIND_TRY_FIRST_PASS_ARG;
else if (!strcasecmp(*v, "unknown_ok"))
ctrl |= WINBIND_UNKNOWN_OK_ARG;
- else if (!strncasecmp(*v, "require_membership_of",
- strlen("require_membership_of")))
+ else if ((type == PAM_WINBIND_AUTHENTICATE
+ || type == PAM_WINBIND_SETCRED)
+ && !strncasecmp(*v, "require_membership_of",
+ strlen("require_membership_of")))
ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
- else if (!strncasecmp(*v, "require-membership-of",
- strlen("require-membership-of")))
+ else if ((type == PAM_WINBIND_AUTHENTICATE
+ || type == PAM_WINBIND_SETCRED)
+ && !strncasecmp(*v, "require-membership-of",
+ strlen("require-membership-of")))
ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
else if (!strcasecmp(*v, "krb5_auth"))
ctrl |= WINBIND_KRB5_AUTH;
ctrl |= WINBIND_CACHED_LOGIN;
else if (!strcasecmp(*v, "mkhomedir"))
ctrl |= WINBIND_MKHOMEDIR;
- else {
+ else if (!strncasecmp(*v, "warn_pwd_expire",
+ strlen("warn_pwd_expire")))
+ ctrl |= WINBIND_WARN_PWD_EXPIRE;
+ else if (!strcasecmp(*v, "pwd_change_prompt"))
+ ctrl |= WINBIND_PWD_CHANGE_PROMPT;
+ else if (type != PAM_WINBIND_CLEANUP) {
__pam_log(pamh, ctrl, LOG_ERR,
"pam_parse: unknown option: %s", *v);
return -1;
*result_d = d;
} else {
if (d) {
- iniparser_freedict(d);
+ tiniparser_freedict(d);
}
}
}
if (ctx->dict) {
- iniparser_freedict(ctx->dict);
+ tiniparser_freedict(ctx->dict);
}
+ wbcCtxFree(ctx->wbc_ctx);
+
return 0;
}
int flags,
int argc,
const char **argv,
+ enum pam_winbind_request_type type,
struct pwb_context **ctx_p)
{
struct pwb_context *r = NULL;
+ const char *service = NULL;
+ char service_name[32] = {0};
+ int ctrl_code;
#ifdef HAVE_GETTEXT
textdomain_init();
r->flags = flags;
r->argc = argc;
r->argv = argv;
- r->ctrl = _pam_parse(pamh, flags, argc, argv, &r->dict);
- if (r->ctrl == -1) {
+ ctrl_code = _pam_parse(pamh, flags, argc, argv, type, &r->dict);
+ if (ctrl_code == -1) {
+ TALLOC_FREE(r);
+ return PAM_SYSTEM_ERR;
+ }
+ r->ctrl = ctrl_code;
+
+ r->wbc_ctx = wbcCtxCreate();
+ if (r->wbc_ctx == NULL) {
TALLOC_FREE(r);
return PAM_SYSTEM_ERR;
}
+ pam_get_item(pamh, PAM_SERVICE, (const void **)&service);
+
+ snprintf(service_name, sizeof(service_name), "PAM_WINBIND[%s]", service);
+
+ wbcSetClientProcessName(service_name);
+
*ctx_p = r;
return PAM_SUCCESS;
void *data,
int error_status)
{
- int ctrl = _pam_parse(pamh, 0, 0, NULL, NULL);
+ int ctrl = _pam_parse(pamh, 0, 0, NULL, PAM_WINBIND_CLEANUP, NULL);
if (_pam_log_is_debug_state_enabled(ctrl)) {
__pam_log_debug(pamh, ctrl, LOG_DEBUG,
"[pamh: %p] CLEAN: cleaning up PAM data %p "
{"NT_STATUS_OK",
N_("Success")},
{"NT_STATUS_BACKUP_CONTROLLER",
- N_("No primary Domain Controler available")},
+ N_("No primary Domain Controller available")},
{"NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND",
N_("No domain controllers found")},
{"NT_STATUS_NO_LOGON_SERVERS",
{"NT_STATUS_PWD_TOO_SHORT",
N_("Password too short")},
{"NT_STATUS_PWD_TOO_RECENT",
- N_("The password of this user is too recent to change")},
+ N_("The password was recently changed and cannot be changed again before %s")},
{"NT_STATUS_PWD_HISTORY_CONFLICT",
N_("Password is already in password history")},
{"NT_STATUS_PASSWORD_EXPIRED",
static int converse(const pam_handle_t *pamh,
int nargs,
- struct pam_message **message,
+ const struct pam_message **message,
struct pam_response **response)
{
int retval;
- struct pam_conv *conv;
+ const struct pam_conv *conv;
retval = pam_get_item(pamh, PAM_CONV, (const void **) &conv);
if (retval == PAM_SUCCESS) {
retval = conv->conv(nargs,
- (const struct pam_message **)message,
+ discard_const_p(const struct pam_message *, message),
response, conv->appdata_ptr);
}
{
int retval = PAM_SUCCESS;
- struct pam_message *pmsg[1], msg[1];
+ const struct pam_message *pmsg[1];
+ struct pam_message msg[1];
struct pam_response *resp;
if (ctx->flags & WINBIND_SILENT) {
return retval;
}
+static int _make_remark_v(struct pwb_context *ctx,
+ int type,
+ const char *format,
+ va_list args) PRINTF_ATTRIBUTE(3, 0);
+
static int _make_remark_v(struct pwb_context *ctx,
int type,
const char *format,
return PAM_IGNORE;
}
return retval;
+ case PAM_AUTHTOK_ERR:
+ /* Authentication token manipulation error */
+ _pam_log(ctx, LOG_WARNING, "user `%s' authentication token change failed "
+ "(pwd complexity/history/min_age not met?)", user);
+ return retval;
case PAM_SUCCESS:
/* Otherwise, the authentication looked good */
if (strcmp(fn, "wbcLogonUser") == 0) {
}
ret = wbc_error_to_pam_error(status);
+ _pam_log(ctx, LOG_ERR,
+ "request %s failed: %s, PAM error: %s (%d)!",
+ fn, wbcErrorString(status),
+ _pam_error_code_str(ret), ret);
return pam_winbind_request_log(ctx, ret, username, fn);
}
#if defined(HAVE_PAM_RADIO_TYPE)
static bool _pam_winbind_change_pwd(struct pwb_context *ctx)
{
- struct pam_message msg, *pmsg;
+ struct pam_message msg;
+ const struct pam_message *pmsg;
struct pam_response *resp = NULL;
int ret;
bool retval = false;
* successfully sent the warning message.
* Give the user a chance to change pwd.
*/
- if (ret == PAM_SUCCESS) {
+ if (ret == PAM_SUCCESS &&
+ (ctx->ctrl & WINBIND_PWD_CHANGE_PROMPT)) {
if (change_pwd) {
retval = _pam_winbind_change_pwd(ctx);
if (retval) {
* successfully sent the warning message.
* Give the user a chance to change pwd.
*/
- if (ret == PAM_SUCCESS) {
+ if (ret == PAM_SUCCESS &&
+ (ctx->ctrl & WINBIND_PWD_CHANGE_PROMPT)) {
if (change_pwd) {
retval = _pam_winbind_change_pwd(ctx);
if (retval) {
static void _pam_warn_password_expiry(struct pwb_context *ctx,
const struct wbcAuthUserInfo *info,
- const struct wbcUserPasswordPolicyInfo *policy,
int warn_pwd_expire,
bool *already_expired,
bool *change_pwd)
time_t now = time(NULL);
time_t next_change = 0;
- if (!info || !policy) {
+ if (info == NULL) {
return;
}
return;
}
- /* now check for the global password policy */
- /* good catch from Ralf Haferkamp: an expiry of "never" is translated
- * to -1 */
- if ((policy->expire == (int64_t)-1) ||
- (policy->expire == 0)) {
- return;
- }
-
- next_change = info->pass_last_set_time + policy->expire;
-
- if (_pam_send_password_expiry_message(ctx, next_change, now,
- warn_pwd_expire,
- already_expired,
- change_pwd)) {
- return;
- }
-
/* no warning sent */
}
const char *src,
int dest_buffer_size)
{
- int dest_length = strlen(dest);
- int src_length = strlen(src);
-
- if (dest_length + src_length + 1 > dest_buffer_size) {
- return false;
- }
-
- memcpy(dest + dest_length, src, src_length + 1);
- return true;
+ size_t len;
+ len = strlcat(dest, src, dest_buffer_size);
+ return (len < dest_buffer_size);
}
/**
_pam_log_debug(ctx, LOG_DEBUG,
"no sid given, looking up: %s\n", name);
- wbc_status = wbcLookupName("", name, &sid, &type);
+ wbc_status = wbcCtxLookupName(ctx->wbc_ctx,
+ "",
+ name,
+ &sid,
+ &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
_pam_log(ctx, LOG_INFO,
"could not lookup name: %s\n", name);
_make_remark_format(ctx, PAM_TEXT_INFO, _("Cannot convert group %s "
"to sid, please contact your administrator to see "
"if group %s is valid."), search_location, search_location);
+
+ /* If no valid groups were converted we should fail outright */
+ if (name_list != NULL && strlen(sid_list_buffer) == 0) {
+ result = false;
+ goto out;
+ }
/*
* The lookup of the last name failed..
* It results in require_member_of_sid ends with ','
- * It is malformated parameter here, overwrite the last ','.
+ * It is malformatted parameter here, overwrite the last ','.
*/
len = strlen(sid_list_buffer);
if ((len != 0) && (sid_list_buffer[len - 1] == ',')) {
}
ret = pam_putenv(ctx->pamh, var);
- if (ret) {
+ if (ret != PAM_SUCCESS) {
_pam_log(ctx, LOG_ERR,
"failed to set KRB5CCNAME to %s: %s",
var, pam_strerror(ctx->pamh, ret));
ret = pam_set_data(ctx->pamh, data_name, talloc_strdup(NULL, value),
_pam_winbind_cleanup_func);
- if (ret) {
+ if (ret != PAM_SUCCESS) {
_pam_log_debug(ctx, LOG_DEBUG,
"Could not set data %s: %s\n",
data_name, pam_strerror(ctx->pamh, ret));
static void _pam_set_data_info3(struct pwb_context *ctx,
const struct wbcAuthUserInfo *info)
{
- _pam_set_data_string(ctx, PAM_WINBIND_HOMEDIR,
+ if (info != NULL) {
+ _pam_set_data_string(ctx, PAM_WINBIND_HOMEDIR,
info->home_directory);
- _pam_set_data_string(ctx, PAM_WINBIND_LOGONSCRIPT,
+ _pam_set_data_string(ctx, PAM_WINBIND_LOGONSCRIPT,
info->logon_script);
- _pam_set_data_string(ctx, PAM_WINBIND_LOGONSERVER,
+ _pam_set_data_string(ctx, PAM_WINBIND_LOGONSERVER,
info->logon_server);
- _pam_set_data_string(ctx, PAM_WINBIND_PROFILEPATH,
+ _pam_set_data_string(ctx, PAM_WINBIND_PROFILEPATH,
info->profile_path);
+ }
}
/**
const char *dirname,
mode_t mode)
{
- struct stat sbuf;
+ int ret;
- if (stat(dirname, &sbuf) == 0) {
- return PAM_SUCCESS;
- }
+ ret = mkdir(dirname, mode);
+ if (ret != 0 && errno == EEXIST) {
+ struct stat sbuf;
- if (mkdir(dirname, mode) != 0) {
+ ret = stat(dirname, &sbuf);
+ if (ret != 0) {
+ return PAM_PERM_DENIED;
+ }
+ if (!S_ISDIR(sbuf.st_mode)) {
+ return PAM_PERM_DENIED;
+ }
+ }
+
+ if (ret != 0) {
_make_remark_format(ctx, PAM_TEXT_INFO,
_("Creating directory: %s failed: %s"),
dirname, strerror(errno));
}
ret = _pam_create_homedir(ctx, create_dir, mode);
- if (ret) {
+ if (ret != PAM_SUCCESS) {
return ret;
}
}
const int warn_pwd_expire,
struct wbcAuthErrorInfo **p_error,
struct wbcLogonUserInfo **p_info,
- struct wbcUserPasswordPolicyInfo **p_policy,
time_t *pwd_last_set,
char **user_ret)
{
wbcErr wbc_status;
-
struct wbcLogonUserParams logon;
char membership_of[1024];
uid_t user_uid = -1;
- uint32_t flags = WBFLAG_PAM_INFO3_TEXT |
- WBFLAG_PAM_GET_PWD_POLICY;
-
+ uint32_t flags = WBFLAG_PAM_INFO3_TEXT;
struct wbcLogonUserInfo *info = NULL;
struct wbcAuthUserInfo *user_info = NULL;
struct wbcAuthErrorInfo *error = NULL;
- struct wbcUserPasswordPolicyInfo *policy = NULL;
-
int ret = PAM_AUTH_ERR;
int i;
const char *codes[] = {
}
}
- wbc_status = wbcLogonUser(&logon, &info, &error, &policy);
+ wbc_status = wbcCtxLogonUser(ctx->wbc_ctx,
+ &logon,
+ &info,
+ &error,
+ NULL);
ret = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
user, "wbcLogonUser");
wbcFreeMemory(logon.blobs);
*p_info = info;
}
- if (p_policy && policy) {
- *p_policy = policy;
- }
-
if (p_error && error) {
/* We want to process the error in the caller. */
*p_error = error;
}
}
- if ((ret == PAM_SUCCESS) && user_info && policy && info) {
+ if ((ret == PAM_SUCCESS) && user_info && info) {
bool already_expired = false;
bool change_pwd = false;
/* warn a user if the password is about to expire soon */
- _pam_warn_password_expiry(ctx, user_info, policy,
+ _pam_warn_password_expiry(ctx, user_info,
warn_pwd_expire,
&already_expired,
&change_pwd);
if (already_expired == true) {
SMB_TIME_T last_set = user_info->pass_last_set_time;
+ SMB_TIME_T must_set = user_info->pass_must_change_time;
_pam_log_debug(ctx, LOG_DEBUG,
"Password has expired "
"(Password was last set: %lld, "
- "the policy says it should expire here "
+ "it must be changed here "
"%lld (now it's: %ld))\n",
(long long int)last_set,
- (long long int)last_set +
- policy->expire,
+ (long long int)must_set,
(long)time(NULL));
return PAM_AUTHTOK_EXPIRED;
wbcFreeMemory(logon.blobs);
if (info && info->blobs && !p_info) {
wbcFreeMemory(info->blobs);
+ /*
+ * We set blobs to NULL to prevent a use after free in the
+ * in the wbcLogonUserInfoDestructor
+ */
+ info->blobs = NULL;
}
if (error && !p_error) {
wbcFreeMemory(error);
if (info && !p_info) {
wbcFreeMemory(info);
}
- if (policy && !p_policy) {
- wbcFreeMemory(policy);
- }
return ret;
}
params.new_password.plaintext = newpass;
params.flags = flags;
- wbc_status = wbcChangeUserPasswordEx(¶ms, &error, &reject_reason, &policy);
+ wbc_status = wbcCtxChangeUserPasswordEx(ctx->wbc_ctx,
+ ¶ms,
+ &error,
+ &reject_reason,
+ &policy);
ret = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
user, "wbcChangeUserPasswordEx");
}
/* FIXME: avoid to send multiple PAM messages after another */
- switch (reject_reason) {
+ switch ((int)reject_reason) {
case -1:
break;
case WBC_PWD_CHANGE_NO_ERROR:
if ((min_pwd_age > 0) &&
(pwd_last_set + min_pwd_age > time(NULL))) {
- PAM_WB_REMARK_DIRECT(ctx,
- "NT_STATUS_PWD_TOO_RECENT");
+ time_t next_change = pwd_last_set + min_pwd_age;
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-nonliteral"
+#endif
+ _make_remark_format(ctx, PAM_ERROR_MSG,
+ _get_ntstatus_error_string("NT_STATUS_PWD_TOO_RECENT"),
+ ctime(&next_change));
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+ goto done;
}
break;
case WBC_PWD_CHANGE_PASSWORD_TOO_SHORT:
return 1;
}
- wbc_status = wbcGetpwnam(user, &wb_pwd);
+ wbc_status = wbcCtxGetpwnam(ctx->wbc_ctx, user, &wb_pwd);
wbcFreeMemory(wb_pwd);
if (!WBC_ERROR_IS_OK(wbc_status)) {
_pam_log(ctx, LOG_DEBUG, "valid_user: wbcGetpwnam gave %s\n",
*/
{
- struct pam_message msg[3], *pmsg[3];
+ struct pam_message msg[3];
+ const struct pam_message *pmsg[3];
struct pam_response *resp;
int i, replies;
goto out;
}
- parm_opt = iniparser_getstring(ctx->dict, key, NULL);
+ parm_opt = tiniparser_getstring_nonempty(ctx->dict, key, NULL);
TALLOC_FREE(key);
_pam_log_debug(ctx, LOG_INFO, "CONFIG file: %s '%s'\n",
goto out;
}
- parm_opt = iniparser_getint(ctx->dict, key, -1);
+ parm_opt = tiniparser_getint(ctx->dict, key, -1);
TALLOC_FREE(key);
_pam_log_debug(ctx, LOG_INFO,
const char *ret = NULL;
ret = get_conf_item_string(ctx, "require_membership_of",
WINBIND_REQUIRED_MEMBERSHIP);
- if (ret) {
+ if (ret != NULL) {
return ret;
}
return get_conf_item_string(ctx, "require-membership-of",
ret = get_config_item_int(ctx, "warn_pwd_expire",
WINBIND_WARN_PWD_EXPIRE);
/* no or broken setting */
- if (ret <= 0) {
+ if (ret < 0) {
return DEFAULT_DAYS_TO_WARN_BEFORE_PWD_EXPIRES;
}
return ret;
{
wbcErr wbc_status;
static struct wbcInterfaceDetails *details = NULL;
+ char result;
- wbc_status = wbcInterfaceDetails(&details);
+ wbc_status = wbcCtxInterfaceDetails(ctx->wbc_ctx, &details);
if (!WBC_ERROR_IS_OK(wbc_status)) {
_pam_log(ctx, LOG_ERR,
"Could not retrieve winbind interface details: %s",
return '\0';
}
- return details->winbind_separator;
+ result = details->winbind_separator;
+ wbcFreeMemory(details);
+ return result;
}
* Convert a upn to a name.
*
* @param ctx PAM winbind context.
- * @param upn USer UPN to be trabslated.
+ * @param upn User UPN to be translated.
*
* @return converted name. NULL pointer on failure. Caller needs to free.
*/
char *domain = NULL;
char *name;
char *p;
+ char *result;
/* This cannot work when the winbind separator = @ */
if (!name) {
return NULL;
}
- if ((p = strchr(name, '@')) != NULL) {
- *p = 0;
- domain = p + 1;
+
+ p = strchr(name, '@');
+ if (p == NULL) {
+ TALLOC_FREE(name);
+ return NULL;
}
+ *p = '\0';
+ domain = p + 1;
/* Convert the UPN to a SID */
- wbc_status = wbcLookupName(domain, name, &sid, &type);
+ wbc_status = wbcCtxLookupName(ctx->wbc_ctx, domain, name, &sid, &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
return NULL;
}
/* Convert the the SID back to the sAMAccountName */
- wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
+ wbc_status = wbcCtxLookupSid(ctx->wbc_ctx, &sid, &domain, &name, &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
return NULL;
}
- return talloc_asprintf(ctx, "%s%c%s", domain, sep, name);
+ result = talloc_asprintf(ctx, "%s%c%s", domain, sep, name);
+ wbcFreeMemory(domain);
+ wbcFreeMemory(name);
+ return result;
}
static int _pam_delete_cred(pam_handle_t *pamh, int flags,
- int argc, const char **argv)
+ int argc, enum pam_winbind_request_type type,
+ const char **argv)
{
int retval = PAM_SUCCESS;
struct pwb_context *ctx = NULL;
ZERO_STRUCT(logoff);
- retval = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (retval) {
- goto out;
+ retval = _pam_winbind_init_context(pamh, flags, argc, argv, type, &ctx);
+ if (retval != PAM_SUCCESS) {
+ return retval;
}
_PAM_LOG_FUNCTION_ENTER("_pam_delete_cred", ctx);
struct passwd *pwd = NULL;
retval = pam_get_user(pamh, &user, _("Username: "));
- if (retval) {
+ if (retval != PAM_SUCCESS) {
_pam_log(ctx, LOG_ERR,
"could not identify user");
goto out;
goto out;
}
- wbc_status = wbcLogoffUserEx(&logoff, &error);
+ wbc_status = wbcCtxLogoffUserEx(ctx->wbc_ctx, &logoff, &error);
retval = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
user, "wbcLogoffUser");
- wbcFreeMemory(error);
wbcFreeMemory(logoff.blobs);
logoff.blobs = NULL;
retval = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
user, "wbcLogoffUser");
}
+ wbcFreeMemory(error);
/*
* Delete the krb5 ccname variable from the PAM environment
return retval;
}
-PAM_EXTERN
+#ifdef SECURITY_OPENPAM_H_INCLUDED
+/*
+ * Logic below is copied from openpam_check_error_code() in
+ *./contrib/openpam/lib/libpam/openpam_dispatch.c on FreeBSD.
+ */
+static int openpam_convert_error_code(struct pwb_context *ctx,
+ enum pam_winbind_request_type req,
+ int r)
+{
+ if (r == PAM_SUCCESS ||
+ r == PAM_SYSTEM_ERR ||
+ r == PAM_SERVICE_ERR ||
+ r == PAM_BUF_ERR ||
+ r == PAM_CONV_ERR ||
+ r == PAM_PERM_DENIED ||
+ r == PAM_ABORT) {
+ return r;
+ }
+
+ /* specific winbind request types */
+ switch (req) {
+ case PAM_WINBIND_AUTHENTICATE:
+ if (r == PAM_AUTH_ERR ||
+ r == PAM_CRED_INSUFFICIENT ||
+ r == PAM_AUTHINFO_UNAVAIL ||
+ r == PAM_USER_UNKNOWN ||
+ r == PAM_MAXTRIES) {
+ return r;
+ }
+ break;
+ case PAM_WINBIND_SETCRED:
+ if (r == PAM_CRED_UNAVAIL ||
+ r == PAM_CRED_EXPIRED ||
+ r == PAM_USER_UNKNOWN ||
+ r == PAM_CRED_ERR) {
+ return r;
+ }
+ break;
+ case PAM_WINBIND_ACCT_MGMT:
+ if (r == PAM_USER_UNKNOWN ||
+ r == PAM_AUTH_ERR ||
+ r == PAM_NEW_AUTHTOK_REQD ||
+ r == PAM_ACCT_EXPIRED) {
+ return r;
+ }
+ break;
+ case PAM_WINBIND_OPEN_SESSION:
+ case PAM_WINBIND_CLOSE_SESSION:
+ if (r == PAM_SESSION_ERR) {
+ return r;
+ }
+ break;
+ case PAM_WINBIND_CHAUTHTOK:
+ if (r == PAM_PERM_DENIED ||
+ r == PAM_AUTHTOK_ERR ||
+ r == PAM_AUTHTOK_RECOVERY_ERR ||
+ r == PAM_AUTHTOK_LOCK_BUSY ||
+ r == PAM_AUTHTOK_DISABLE_AGING ||
+ r == PAM_TRY_AGAIN) {
+ return r;
+ }
+ break;
+ default:
+ break;
+ }
+ _pam_log(ctx, LOG_INFO,
+ "Converting PAM error [%d] to PAM_SERVICE_ERR.\n", r);
+ return PAM_SERVICE_ERR;
+};
+#define pam_error_code(a, b, c) openpam_convert_error_code(a, b, c)
+#else
+#define pam_error_code(a, b, c) (c)
+#endif
+
+_PUBLIC_ PAM_EXTERN
int pam_sm_authenticate(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
char *real_username = NULL;
struct pwb_context *ctx = NULL;
- retval = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (retval) {
- goto out;
+ retval = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_AUTHENTICATE, &ctx);
+ if (retval != PAM_SUCCESS) {
+ return retval;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_authenticate", ctx);
/* Now use the username to look up password */
retval = winbind_auth_request(ctx, real_username, password,
member, cctype, warn_pwd_expire,
- NULL, NULL, NULL,
- NULL, &username_ret);
+ NULL, NULL, NULL, &username_ret);
if (retval == PAM_NEW_AUTHTOK_REQD ||
retval == PAM_AUTHTOK_EXPIRED) {
_pam_free_data_info3(pamh);
}
- if (ctx != NULL) {
- _PAM_LOG_FUNCTION_LEAVE("pam_sm_authenticate", ctx, retval);
- TALLOC_FREE(ctx);
- }
+ _PAM_LOG_FUNCTION_LEAVE("pam_sm_authenticate", ctx, retval);
+
+ TALLOC_FREE(ctx);
return retval;
}
-PAM_EXTERN
+_PUBLIC_ PAM_EXTERN
int pam_sm_setcred(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
int ret = PAM_SYSTEM_ERR;
struct pwb_context *ctx = NULL;
- ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (ret) {
- goto out;
+ ret = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_SETCRED, &ctx);
+ if (ret != PAM_SUCCESS) {
+ return ret;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_setcred", ctx);
switch (flags & ~PAM_SILENT) {
case PAM_DELETE_CRED:
- ret = _pam_delete_cred(pamh, flags, argc, argv);
+ ret = _pam_delete_cred(pamh, flags, argc,
+ PAM_WINBIND_SETCRED, argv);
break;
case PAM_REFRESH_CRED:
_pam_log_debug(ctx, LOG_WARNING,
break;
}
- out:
-
_PAM_LOG_FUNCTION_LEAVE("pam_sm_setcred", ctx, ret);
TALLOC_FREE(ctx);
- return ret;
+ return pam_error_code(ctx, PAM_WINBIND_SETCRED, ret);
}
/*
* Account management. We want to verify that the account exists
* before returning PAM_SUCCESS
*/
-PAM_EXTERN
+_PUBLIC_ PAM_EXTERN
int pam_sm_acct_mgmt(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
const char *tmp = NULL;
struct pwb_context *ctx = NULL;
- ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (ret) {
- goto out;
+ ret = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_ACCT_MGMT, &ctx);
+ if (ret != PAM_SUCCESS) {
+ return ret;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_acct_mgmt", ctx);
ret = atoi(tmp);
switch (ret) {
case PAM_AUTHTOK_EXPIRED:
- /* fall through, since new token is required in this case */
+ /* Since new token is required in this case */
+ FALL_THROUGH;
case PAM_NEW_AUTHTOK_REQD:
_pam_log(ctx, LOG_WARNING,
"pam_sm_acct_mgmt success but %s is set",
TALLOC_FREE(ctx);
- return ret;
+ return pam_error_code(ctx, PAM_WINBIND_ACCT_MGMT, ret);
}
-PAM_EXTERN
+_PUBLIC_ PAM_EXTERN
int pam_sm_open_session(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
int ret = PAM_SUCCESS;
struct pwb_context *ctx = NULL;
- ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (ret) {
- goto out;
+ ret = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_OPEN_SESSION, &ctx);
+ if (ret != PAM_SUCCESS) {
+ return ret;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_open_session", ctx);
/* check and create homedir */
ret = _pam_mkhomedir(ctx);
}
- out:
+
_PAM_LOG_FUNCTION_LEAVE("pam_sm_open_session", ctx, ret);
TALLOC_FREE(ctx);
- return ret;
+ return pam_error_code(ctx, PAM_WINBIND_OPEN_SESSION, ret);
}
-PAM_EXTERN
+_PUBLIC_ PAM_EXTERN
int pam_sm_close_session(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
int ret = PAM_SUCCESS;
struct pwb_context *ctx = NULL;
- ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (ret) {
- goto out;
+ ret = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_CLOSE_SESSION, &ctx);
+ if (ret != PAM_SUCCESS) {
+ return ret;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_close_session", ctx);
-out:
_PAM_LOG_FUNCTION_LEAVE("pam_sm_close_session", ctx, ret);
TALLOC_FREE(ctx);
- return ret;
+ return pam_error_code(ctx, PAM_WINBIND_CLOSE_SESSION, ret);
}
/**
* --- BoYang
* */
- char *new_authtok_reqd_during_auth = NULL;
+ const char *new_authtok_reqd_during_auth = NULL;
struct passwd *pwd = NULL;
pam_get_data(ctx->pamh, PAM_WINBIND_NEW_AUTHTOK_REQD_DURING_AUTH,
}
-PAM_EXTERN
+_PUBLIC_ PAM_EXTERN
int pam_sm_chauthtok(pam_handle_t * pamh, int flags,
int argc, const char **argv)
{
struct wbcAuthErrorInfo *error = NULL;
struct pwb_context *ctx = NULL;
- ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
- if (ret) {
- goto out;
+ ret = _pam_winbind_init_context(pamh, flags, argc, argv,
+ PAM_WINBIND_CHAUTHTOK, &ctx);
+ if (ret != PAM_SUCCESS) {
+ return ret;
}
_PAM_LOG_FUNCTION_ENTER("pam_sm_chauthtok", ctx);
* First get the name of a user
*/
ret = pam_get_user(pamh, &user, _("Username: "));
- if (ret) {
+ if (ret != PAM_SUCCESS) {
_pam_log(ctx, LOG_ERR,
"password - could not identify user");
goto out;
*/
if (flags & PAM_PRELIM_CHECK) {
- time_t pwdlastset_prelim = 0;
+ time_t *pwdlastset_prelim = NULL;
+
+ pwdlastset_prelim = talloc_zero(NULL, time_t);
+ if (pwdlastset_prelim == NULL) {
+ _pam_log(ctx, LOG_CRIT,
+ "password - out of memory");
+ ret = PAM_BUF_ERR;
+ goto out;
+ }
/* instruct user what is happening */
ret = winbind_auth_request(ctx, user, pass_old,
NULL, NULL, 0,
- &error, NULL, NULL,
- &pwdlastset_prelim, NULL);
+ &error, NULL,
+ pwdlastset_prelim, NULL);
if (ret != PAM_ACCT_EXPIRED &&
ret != PAM_AUTHTOK_EXPIRED &&
}
pam_set_data(pamh, PAM_WINBIND_PWD_LAST_SET,
- (void *)pwdlastset_prelim, NULL);
+ pwdlastset_prelim,
+ _pam_winbind_cleanup_func);
ret = pam_set_item(pamh, PAM_OLDAUTHTOK,
(const void *) pass_old);
"failed to set PAM_OLDAUTHTOK");
}
} else if (flags & PAM_UPDATE_AUTHTOK) {
-
- time_t pwdlastset_update = 0;
+ const time_t *pwdlastset_update = NULL;
/*
* obtain the proposed password
if (on(WINBIND_USE_AUTHTOK_ARG, lctrl)) {
lctrl |= WINBIND_USE_FIRST_PASS_ARG;
}
+ if (on(WINBIND_TRY_AUTHTOK_ARG, lctrl)) {
+ lctrl |= WINBIND_TRY_FIRST_PASS_ARG;
+ }
retry = 0;
ret = PAM_AUTHTOK_ERR;
while ((ret != PAM_SUCCESS) && (retry++ < MAX_PASSWD_TRIES)) {
* By reaching here we have approved the passwords and must now
* rebuild the password database file.
*/
- pam_get_data(pamh, PAM_WINBIND_PWD_LAST_SET,
- (const void **) &pwdlastset_update);
+ pam_get_data(pamh,
+ PAM_WINBIND_PWD_LAST_SET,
+ (const void **)(&pwdlastset_update));
/*
* if cached creds were enabled, make sure to set the
}
ret = winbind_chauthtok_request(ctx, user, pass_old,
- pass_new, pwdlastset_update);
- if (ret) {
+ pass_new, *pwdlastset_update);
+ if (ret != PAM_SUCCESS) {
pass_old = pass_new = NULL;
goto out;
}
const char *cctype = NULL;
int warn_pwd_expire;
struct wbcLogonUserInfo *info = NULL;
- struct wbcUserPasswordPolicyInfo *policy = NULL;
member = get_member_from_config(ctx);
cctype = get_krb5_cc_type_from_config(ctx);
ret = winbind_auth_request(ctx, user, pass_new,
member, cctype, 0,
- &error, &info, &policy,
+ &error, &info,
NULL, &username_ret);
pass_old = pass_new = NULL;
/* warn a user if the password is about to
* expire soon */
- _pam_warn_password_expiry(ctx, user_info, policy,
+ _pam_warn_password_expiry(ctx, user_info,
warn_pwd_expire,
NULL, NULL);
wbcFreeMemory(info->blobs);
}
wbcFreeMemory(info);
- wbcFreeMemory(policy);
goto out;
}
TALLOC_FREE(ctx);
- return ret;
+ return pam_error_code(ctx, PAM_WINBIND_CHAUTHTOK, ret);
}
#ifdef PAM_STATIC
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff