Copyright (C) Andrew Bartlett 2001-2011
Copyright (C) Jeremy Allison 2000-2001
Copyright (C) Rafal Szczesniak 2002
- Copyright (C) Volker Lendecke 2006
+ Copyright (C) Volker Lendecke 2006-2008
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "../lib/util/util_pw.h"
#include "lib/winbind_util.h"
#include "passdb.h"
+#include "../librpc/gen_ndr/ndr_auth.h"
+#include "../auth/auth_sam_reply.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_AUTH
-static struct auth3_session_info *copy_serverinfo_session_info(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *src);
-
/****************************************************************************
Create a UNIX user on demand.
****************************************************************************/
}
/****************************************************************************
- Create a guest user_info blob, for anonymous authenticaion.
+ Create a guest user_info blob, for anonymous authentication.
****************************************************************************/
bool make_user_info_guest(const struct tsocket_address *remote_address,
NTSTATUS create_local_token(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
DATA_BLOB *session_key,
- struct auth3_session_info **session_info_out)
+ struct auth_session_info **session_info_out)
{
struct security_token *t;
NTSTATUS status;
size_t i;
struct dom_sid tmp_sid;
- struct auth3_session_info *session_info;
+ struct auth_session_info *session_info;
struct wbcUnixId *ids;
/* Ensure we can't possible take a code path leading to a
return NT_STATUS_LOGON_FAILURE;
}
- session_info = copy_serverinfo_session_info(mem_ctx, server_info);
-
+ session_info = talloc_zero(mem_ctx, struct auth_session_info);
if (!session_info) {
return NT_STATUS_NO_MEMORY;
}
+ session_info->unix_token = talloc_zero(session_info, struct security_unix_token);
+ if (!session_info->unix_token) {
+ TALLOC_FREE(session_info);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ session_info->unix_token->uid = server_info->utok.uid;
+ session_info->unix_token->gid = server_info->utok.gid;
+
+ session_info->unix_info = talloc_zero(session_info, struct auth_user_info_unix);
+ if (!session_info->unix_info) {
+ TALLOC_FREE(session_info);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ session_info->unix_info->unix_name = talloc_strdup(session_info, server_info->unix_name);
+ if (!session_info->unix_info->unix_name) {
+ TALLOC_FREE(session_info);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ session_info->unix_info->sanitized_username = talloc_strdup(session_info, server_info->sanitized_username);
+ if (!session_info->unix_info->sanitized_username) {
+ TALLOC_FREE(session_info);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ session_info->unix_info->system = server_info->system;
+
if (session_key) {
data_blob_free(&session_info->session_key);
session_info->session_key = data_blob_talloc(session_info,
if (!session_info->session_key.data && session_key->length) {
return NT_STATUS_NO_MEMORY;
}
+ } else {
+ session_info->session_key = data_blob_talloc( session_info, server_info->session_key.data,
+ server_info->session_key.length);
}
if (session_info->security_token) {
* (nasty hack to support a cached guest session_info,
* and a possible strategy for auth_samba4 to pass in
* a finalised session) */
+
+ session_info->security_token = dup_nt_token(session_info, server_info->security_token);
+ if (!session_info->security_token) {
+ TALLOC_FREE(session_info);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ session_info->unix_token->ngroups = server_info->utok.ngroups;
+ if (server_info->utok.ngroups != 0) {
+ session_info->unix_token->groups = (gid_t *)talloc_memdup(
+ session_info->unix_token, server_info->utok.groups,
+ sizeof(gid_t)*session_info->unix_token->ngroups);
+ } else {
+ session_info->unix_token->groups = NULL;
+ }
+
*session_info_out = session_info;
return NT_STATUS_OK;
}
+ /* We need to populate session_info->info with the information found in server_info->info3 */
+ status = make_user_info_SamBaseInfo(session_info, "", &server_info->info3->base,
+ server_info->guest == false,
+ &session_info->info);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("conversion of info3 into auth_user_info failed!\n"));
+ TALLOC_FREE(session_info);
+ return status;
+ }
+
/*
* If winbind is not around, we can not make much use of the SIDs the
* domain controller provided us with. Likewise if the user name was
return NT_STATUS_NO_SUCH_USER;
}
- /* Set acount name */
+ /* Set account name */
tmp = talloc_strdup(mem_ctx, pwd->pw_name);
if (tmp == NULL) {
return NT_STATUS_NO_MEMORY;
/* Primary gid */
info3->base.primary_gid = BUILTIN_RID_GUESTS;
+ /* Set as guest */
+ info3->base.user_flags = NETLOGON_GUEST;
+
TALLOC_FREE(pwd);
return NT_STATUS_OK;
}
The resulting structure is a 'session_info' because
create_local_token() has already been called on it. This is quite
- nasty, as the auth subsystem isn't expect this, but the behaviour is
+ nasty, as the auth subsystem isn't expect this, but the behavior is
left as-is for now.
***************************************************************************/
-static NTSTATUS make_new_session_info_guest(struct auth3_session_info **session_info)
+static NTSTATUS make_new_session_info_guest(struct auth_session_info **session_info, struct auth_serversupplied_info **server_info)
{
- struct auth_serversupplied_info *server_info;
static const char zeros[16] = {0};
const char *guest_account = lp_guestaccount();
const char *domain = lp_netbios_name();
status = make_server_info_info3(tmp_ctx,
guest_account,
domain,
- &server_info,
+ server_info,
&info3);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("make_server_info_info3 failed with %s\n",
goto done;
}
- server_info->guest = True;
+ (*server_info)->guest = True;
/* This should not be done here (we should produce a server
* info, and later construct a session info from it), but for
- * now this does not change the previous behaviours */
- status = create_local_token(tmp_ctx, server_info, NULL, session_info);
- TALLOC_FREE(server_info);
+ * now this does not change the previous behavior */
+ status = create_local_token(tmp_ctx, *server_info, NULL, session_info);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("create_local_token failed: %s\n",
nt_errstr(status)));
goto done;
}
talloc_steal(NULL, *session_info);
+ talloc_steal(NULL, *server_info);
/* annoying, but the Guest really does have a session key, and it is
all zeros! */
(*session_info)->session_key = data_blob(zeros, sizeof(zeros));
- alpha_strcpy(tmp, (*session_info)->info3->base.account_name.string,
+ alpha_strcpy(tmp, (*server_info)->info3->base.account_name.string,
". _-$", sizeof(tmp));
(*session_info)->unix_info->sanitized_username = talloc_strdup(*session_info, tmp);
***************************************************************************/
static NTSTATUS make_new_session_info_system(TALLOC_CTX *mem_ctx,
- struct auth3_session_info **session_info)
+ struct auth_session_info **session_info)
{
struct passwd *pwd;
NTSTATUS status;
}
/****************************************************************************
- Fake a auth3_session_info just from a username (as a
+ Fake a auth_session_info just from a username (as a
session_info structure, with create_local_token() already called on
it.
****************************************************************************/
NTSTATUS make_session_info_from_username(TALLOC_CTX *mem_ctx,
const char *username,
bool is_guest,
- struct auth3_session_info **session_info)
+ struct auth_session_info **session_info)
{
struct auth_serversupplied_info *result;
struct passwd *pwd;
* guest.
*
* This is a lossy conversion. Variables known to be lost so far
- * include: nss_token (not needed because the only read doesn't happen
+ * include:
+ *
+ * - nss_token (not needed because the only read doesn't happen
* for the GUEST user, as this routine populates ->security_token
+ *
+ * - extra (not needed because the guest account must have valid RIDs per the output of get_guest_info3())
+ *
+ * - The 'server_info' parameter allows the missing 'info3' to be copied across.
*/
-static struct auth_serversupplied_info *copy_session_info_serverinfo(TALLOC_CTX *mem_ctx,
- const struct auth3_session_info *src)
+static struct auth_serversupplied_info *copy_session_info_serverinfo_guest(TALLOC_CTX *mem_ctx,
+ const struct auth_session_info *src,
+ struct auth_serversupplied_info *server_info)
{
struct auth_serversupplied_info *dst;
/* This element must be provided to convert back to an auth_serversupplied_info */
SMB_ASSERT(src->unix_info);
- dst->guest = src->unix_info->guest;
- dst->system = src->unix_info->system;
+ dst->guest = true;
+ dst->system = false;
- /* This element must be provided to convert back to an auth_serversupplied_info */
+ /* This element must be provided to convert back to an
+ * auth_serversupplied_info. This needs to be from the
+ * auth_session_info because the group values in particular
+ * may change during create_local_token() processing */
SMB_ASSERT(src->unix_token);
dst->utok.uid = src->unix_token->uid;
dst->utok.gid = src->unix_token->gid;
dst->lm_session_key = data_blob_talloc(dst, src->session_key.data,
src->session_key.length);
- dst->info3 = copy_netr_SamInfo3(dst, src->info3);
+ dst->info3 = copy_netr_SamInfo3(dst, server_info->info3);
if (!dst->info3) {
TALLOC_FREE(dst);
return NULL;
}
- dst->extra = src->extra;
dst->unix_name = talloc_strdup(dst, src->unix_info->unix_name);
if (!dst->unix_name) {
return dst;
}
-static struct auth3_session_info *copy_serverinfo_session_info(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *src)
+struct auth_session_info *copy_session_info(TALLOC_CTX *mem_ctx,
+ const struct auth_session_info *src)
{
- struct auth3_session_info *dst;
-
- dst = make_auth3_session_info(mem_ctx);
- if (dst == NULL) {
- return NULL;
- }
-
- dst->unix_token = talloc(dst, struct security_unix_token);
- if (!dst->unix_token) {
- return NULL;
- }
-
- dst->unix_token->uid = src->utok.uid;
- dst->unix_token->gid = src->utok.gid;
- dst->unix_token->ngroups = src->utok.ngroups;
- if (src->utok.ngroups != 0) {
- dst->unix_token->groups = (gid_t *)talloc_memdup(
- dst->unix_token, src->utok.groups,
- sizeof(gid_t)*dst->unix_token->ngroups);
- } else {
- dst->unix_token->groups = NULL;
- }
-
- if (src->security_token) {
- dst->security_token = dup_nt_token(dst, src->security_token);
- if (!dst->security_token) {
- TALLOC_FREE(dst);
- return NULL;
- }
- }
-
- dst->session_key = data_blob_talloc( dst, src->session_key.data,
- src->session_key.length);
-
- dst->info3 = copy_netr_SamInfo3(dst, src->info3);
- if (!dst->info3) {
- TALLOC_FREE(dst);
+ struct auth_session_info *dst;
+ DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
+
+ ndr_err = ndr_push_struct_blob(
+ &blob, talloc_tos(), src,
+ (ndr_push_flags_fn_t)ndr_push_auth_session_info);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(0, ("copy_session_info(): ndr_push_auth_session_info failed: "
+ "%s\n", ndr_errstr(ndr_err)));
return NULL;
}
- dst->extra = src->extra;
- dst->unix_info = talloc_zero(dst, struct auth_user_info_unix);
- if (!dst->unix_info) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->unix_name = talloc_strdup(dst, src->unix_name);
- if (!dst->unix_info->unix_name) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->sanitized_username = talloc_strdup(dst, src->sanitized_username);
- if (!dst->unix_info->sanitized_username) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->guest = src->guest;
- dst->unix_info->system = src->system;
-
- return dst;
-}
-
-struct auth3_session_info *copy_session_info(TALLOC_CTX *mem_ctx,
- const struct auth3_session_info *src)
-{
- struct auth3_session_info *dst;
-
- dst = make_auth3_session_info(mem_ctx);
+ dst = talloc(mem_ctx, struct auth_session_info);
if (dst == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ TALLOC_FREE(blob.data);
return NULL;
}
- if (src->unix_token) {
- dst->unix_token = talloc(dst, struct security_unix_token);
- if (!dst->unix_token) {
- return NULL;
- }
+ ndr_err = ndr_pull_struct_blob(
+ &blob, dst, dst,
+ (ndr_pull_flags_fn_t)ndr_pull_auth_session_info);
+ TALLOC_FREE(blob.data);
- dst->unix_token->uid = src->unix_token->uid;
- dst->unix_token->gid = src->unix_token->gid;
- dst->unix_token->ngroups = src->unix_token->ngroups;
- if (src->unix_token->ngroups != 0) {
- dst->unix_token->groups = (gid_t *)talloc_memdup(
- dst->unix_token, src->unix_token->groups,
- sizeof(gid_t)*dst->unix_token->ngroups);
- } else {
- dst->unix_token->groups = NULL;
- }
- } else {
- dst->unix_token = NULL;
- }
-
- if (src->security_token) {
- dst->security_token = dup_nt_token(dst, src->security_token);
- if (!dst->security_token) {
- TALLOC_FREE(dst);
- return NULL;
- }
- }
-
- dst->session_key = data_blob_talloc( dst, src->session_key.data,
- src->session_key.length);
-
- dst->info3 = copy_netr_SamInfo3(dst, src->info3);
- if (!dst->info3) {
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(0, ("copy_session_info(): ndr_pull_auth_session_info failed: "
+ "%s\n", ndr_errstr(ndr_err)));
TALLOC_FREE(dst);
return NULL;
}
- dst->extra = src->extra;
-
- if (src->unix_info) {
- dst->unix_info = talloc_zero(dst, struct auth_user_info_unix);
- if (!dst->unix_info) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->unix_name = talloc_strdup(dst, src->unix_info->unix_name);
- if (!dst->unix_info->unix_name) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->sanitized_username = talloc_strdup(dst, src->unix_info->sanitized_username);
- if (!dst->unix_info->sanitized_username) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
- dst->unix_info->guest = src->unix_info->guest;
- dst->unix_info->system = src->unix_info->system;
- }
return dst;
}
* SMB level session key with SystemLibraryDTC
*/
-bool session_info_set_session_key(struct auth3_session_info *info,
+bool session_info_set_session_key(struct auth_session_info *info,
DATA_BLOB session_key)
{
TALLOC_FREE(info->session_key.data);
return (info->session_key.data != NULL);
}
-static struct auth3_session_info *guest_info = NULL;
+static struct auth_session_info *guest_info = NULL;
+
+static struct auth_serversupplied_info *guest_server_info = NULL;
bool init_guest_info(void)
{
if (guest_info != NULL)
return True;
- return NT_STATUS_IS_OK(make_new_session_info_guest(&guest_info));
+ return NT_STATUS_IS_OK(make_new_session_info_guest(&guest_info, &guest_server_info));
}
NTSTATUS make_server_info_guest(TALLOC_CTX *mem_ctx,
struct auth_serversupplied_info **server_info)
{
- *server_info = copy_session_info_serverinfo(mem_ctx, guest_info);
+ /* This is trickier than it would appear to need to be because
+ * we are trying to avoid certain costly operations when the
+ * structure is converted to a 'auth_session_info' again in
+ * create_local_token() */
+ *server_info = copy_session_info_serverinfo_guest(mem_ctx, guest_info, guest_server_info);
return (*server_info != NULL) ? NT_STATUS_OK : NT_STATUS_NO_MEMORY;
}
NTSTATUS make_session_info_guest(TALLOC_CTX *mem_ctx,
- struct auth3_session_info **session_info)
+ struct auth_session_info **session_info)
{
*session_info = copy_session_info(mem_ctx, guest_info);
return (*session_info != NULL) ? NT_STATUS_OK : NT_STATUS_NO_MEMORY;
}
-static struct auth3_session_info *system_info = NULL;
+static struct auth_session_info *system_info = NULL;
NTSTATUS init_system_info(void)
{
}
NTSTATUS make_session_info_system(TALLOC_CTX *mem_ctx,
- struct auth3_session_info **session_info)
+ struct auth_session_info **session_info)
{
if (system_info == NULL) return NT_STATUS_UNSUCCESSFUL;
*session_info = copy_session_info(mem_ctx, system_info);
return (*session_info != NULL) ? NT_STATUS_OK : NT_STATUS_NO_MEMORY;
}
-const struct auth3_session_info *get_session_info_system(void)
+const struct auth_session_info *get_session_info_system(void)
{
return system_info;
}
*pwd = passwd;
- /* This is pointless -- there is no suport for differing
+ /* This is pointless -- there is no support for differing
unix and windows names. Make sure to always store the
one we actually looked up and succeeded. Have I mentioned
why I hate the 'winbind use default domain' parameter?
result->utok.gid = pwd->pw_gid;
/* We can't just trust that the primary group sid sent us is something
- * we can really use. Obtain the useable sid, and store the original
+ * we can really use. Obtain the usable sid, and store the original
* one as an additional group if it had to be replaced */
nt_status = get_primary_group_sid(mem_ctx, found_username,
&pwd, &group_sid);